buildz 0.6.58__tar.gz → 0.6.60__tar.gz

{buildz-0.6.58/buildz.egg-info → buildz-0.6.60}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buildz
-Version: 0.6.58
+Version: 0.6.60
 Summary: 配置读写（基于json格式进行简化）、ioc、以及其他工具代码。a json-base file format's read and write code by python, and codes to read and product object from configure file in such format(ioc), and other tool codes
 Home-page: https://github.com/buildCodeZ/buildz
 Author: Zzz

{buildz-0.6.58 → buildz-0.6.60}/buildz/__init__.py

@@ -1,6 +1,6 @@
 #coding=utf-8
 
-__version__="0.6.34"
+__version__="0.6.60"
 
 # 小号多
 __author__ = "Zzz, emails: 1174534295@qq.com, 1309458652@qq.com"

buildz-0.6.60/buildz/gpuz/test/report.txt

@@ -0,0 +1,50 @@
+
+测试结果: 
+结论是：大概能达到纯显卡（75W，更高的没测）二分之一或三分之一的性能，显存不够的可以用用，主要是卷积层，卷积层cpu计算耗时很大，并且神经网络参数相对较少，线性层感觉cpu和显卡本来就差不太多
+
+环境: 
+    笔记本（游戏本）
+    显卡: RTX4060 8GB 75W残血版
+    CPU: i7-13700H
+    内存: 16GB
+
+1）线性层测试：
+模型: 
+    float32，120层，每层的输入输出维度都是2000，数据量1.789GB，每个线性层后面加一个LeakyReLU激活函数
+数据: 
+    60个数据，每个数据2000维度，分成两个批量（每个批量30个数据），数据量0.000447GB
+
+训练一次（两个批量的数据）平均耗时
+纯显卡: 4.13秒
+纯CPU耗时: 14.7秒
+模型分层，轮流传显卡里计算: 3.67秒（因为显存足够，实际上等于纯显卡）
+模型分层，显卡已经被使用2.3GB: 6.5秒
+模型分层，显卡已经被使用3.9GB: 9.5秒
+
+2）卷积测试：
+模型：
+    float32，60层，卷积核输入输出channel都是3，卷积核大小5，数据量0.00005GB，每个线性层后面加一个LeakyReLU激活函数
+数据：
+    20个数据，每个数据3个通道*512宽*512高，分成两个批量（每个批量10个数据），数据量0.059GB
+
+训练一次（两个批量的数据）平均耗时
+纯显卡: 1.52秒
+纯CPU耗时: 41秒
+模型分层，轮流传显卡里计算: 3.36秒（因为显存足够，实际上等于纯显卡）
+纯显卡，显卡已经被使用3.9GB: 23秒（cuda+torch奇葩的地方出现了，猜测是在显存不够的时候，舍弃一些计算反向梯度要用的缓存，反向梯度的时候重新计算，导致时间开销增大很多）
+模型分层，显卡已经被使用3.9GB: 3.3秒
+
+
+
+3）卷积测试1(test_middle_conv1.py)：
+模型：
+    float32，22层网络，卷积核大小5，每层网络两层卷积（30通道到60通道一层卷积，60通道回到30通道一层卷积）再加一个LeakyReLU激活函数，数据量0.0074GB，每个线性层后面加一个LeakyReLU激活函数
+数据：
+    6个数据，每个数据30个通道*512宽*512高，分成三个批量（每个批量2个数据），数据量0.059GB
+
+训练一次（两个批量的数据）平均耗时
+纯显卡: 3.73秒
+纯CPU耗时: 44秒
+模型分层，轮流传显卡里计算: 7.5秒（因为显存足够，实际上等于纯显卡）
+纯显卡，显卡已经被使用3.9GB: 116秒
+模型分层，显卡已经被使用3.9GB: 7.7秒

buildz-0.6.60/buildz/gpuz/test/test_middle.py

@@ -0,0 +1,118 @@
+#
+
+from buildz.gpuz.torch import CacheModel
+import sys
+import torch,time
+from torch import nn,optim
+from torch.utils.data import DataLoader, Dataset
+cpu = torch.device('cpu')
+cuda = cpu
+if torch.cuda.is_available():
+    cuda = torch.device('cuda')
+def sz(tensor):
+    return tensor.element_size()*tensor.nelement()
+class Model(nn.Module):
+    def __init__(self, dims, num):
+        super().__init__()
+        #nets = [nn.Conv2d(3, 3, 5, padding=2) for i in range(num)]
+        nets=[]
+        for i in range(num):
+            nets.append(nn.Linear(dims,dims))
+            nets.append(nn.LeakyReLU())
+        #nets = [nn.Linear(dims,dims) for i in range(num)]
+        print(f"nets:{len(nets)}")
+        self.nets = nn.Sequential(*nets)
+    def forward(self, inputs):
+        return self.nets(inputs)
+    def size(self):
+        total = 0.0
+        for net in self.nets:
+            if not hasattr(net, "weight"):
+                continue
+            w = net.weight
+            b = net.bias
+            total+=sz(w)+sz(b)
+        return total
+
+pass
+class TestDataset(Dataset):
+    def __init__(self, n, dims):
+        self.n = n
+        self.dims = dims
+        self.datas = torch.rand(n, dims)
+        print(f"data size: {sz(self.datas)/1024/1024/1024} GB")
+    def __len__(self):
+        return self.n
+    def __getitem__(self, i):
+        return self.datas[i]
+        return torch.rand(self.dims)
+
+pass
+def fc_opt(net, opt):
+    #torch.nn.utils.clip_grad_norm_(net.parameters(), max_norm=1.0)
+    opt.step()
+def test():
+    nets=10
+    dims=2000
+    trains = 5
+    datas = 60
+    batch=30
+    lr=0.0001
+    win_size=3
+    num = 12
+    mds = [Model(dims, nets) for i in range(num)]
+    mds_sz = [md.size() for md in mds]
+    print(f"Model Size: {sum(mds_sz)/1024/1024/1024} GB")
+    opts =[optim.Adam(md.parameters(), lr=lr) for md in mds]
+    cuda=cpu
+    ds = TestDataset(datas, dims)
+    dl = DataLoader(ds, batch)
+    #return
+    loss_fn = torch.nn.MSELoss()
+    print("start train")
+    nets= []
+    for md in mds:
+        nets+=md.nets
+    gmodel = nn.Sequential(*nets)
+    gmodel = gmodel.to(cuda)
+    gopt = optim.Adam(gmodel.parameters(), lr=lr)
+    gmodel.train()
+    #with torch.no_grad():
+    for i in range(trains):
+        total_loss = 0
+        curr=time.time()
+        for dt in dl:
+            dt=dt.to(cuda)
+            gopt.zero_grad()
+            out = gmodel(dt)
+            loss = loss_fn(out, dt)
+            print(f"loss: {loss, type(loss)}")
+            loss.backward()
+            gopt.step()
+            total_loss+=loss.item()
+        sec = time.time()-curr
+        print("train:", i, "loss:", total_loss/len(dl), "time:", sec)
+    del gmodel,gopt
+    torch.cuda.empty_cache()
+    input("start middle:")
+    md = CacheModel(cuda, cpu, mds, opts, win_size, fc_opt)
+    md.nfc("train")
+    #with torch.no_grad():
+    for i in range(trains):
+        total_loss = 0
+        curr=time.time()
+        for dt in dl:
+            dt=dt.to(cuda)
+            [opt.zero_grad() for opt in opts]
+            out = md.do_forward(dt)
+            loss = loss_fn(out, dt)
+            print(f"loss: {loss, type(loss)}")
+            md.do_backward(lambda : loss.backward())
+            total_loss+=loss.item()
+        sec = time.time()-curr
+        print("train:", i, "loss:", total_loss/len(dl), "time:", sec)
+
+    
+
+pass
+test()

buildz-0.6.60/buildz/gpuz/test/test_middle_conv.py

@@ -0,0 +1,118 @@
+#
+
+from buildz.gpuz.torch import CacheModel
+import sys
+import torch,time
+from torch import nn,optim
+from torch.utils.data import DataLoader, Dataset
+cpu = torch.device('cpu')
+cuda = cpu
+if torch.cuda.is_available():
+    cuda = torch.device('cuda')
+def sz(tensor):
+    return tensor.element_size()*tensor.nelement()
+class Model(nn.Module):
+    def __init__(self, dims, num):
+        super().__init__()
+        #nets = [nn.Conv2d(3, 3, 5, padding=2) for i in range(num)]
+        nets=[]
+        for i in range(num):
+            nets.append(nn.Conv2d(3, 3, 5, padding=2))
+            nets.append(nn.LeakyReLU())
+        #nets = [nn.Linear(dims,dims) for i in range(num)]
+        print(f"nets:{len(nets)}")
+        self.nets = nn.Sequential(*nets)
+    def forward(self, inputs):
+        return self.nets(inputs)
+    def size(self):
+        total = 0.0
+        for net in self.nets:
+            if not hasattr(net, "weight"):
+                continue
+            w = net.weight
+            b = net.bias
+            total+=sz(w)+sz(b)
+        return total
+
+pass
+class TestDataset(Dataset):
+    def __init__(self, n, dims):
+        self.n = n
+        self.dims = dims
+        self.datas = torch.rand(n, 3,dims,dims)
+        print(f"data size: {sz(self.datas)/1024/1024/1024} GB")
+    def __len__(self):
+        return self.n
+    def __getitem__(self, i):
+        return self.datas[i]
+        return torch.rand(self.dims)
+
+pass
+def fc_opt(net, opt):
+    #torch.nn.utils.clip_grad_norm_(net.parameters(), max_norm=1.0)
+    opt.step()
+def test():
+    nets=5
+    dims=512
+    trains = 5
+    datas = 20
+    batch=10
+    lr=0.0001
+    win_size=3
+    num = 12
+    mds = [Model(dims, nets) for i in range(num)]
+    mds_sz = [md.size() for md in mds]
+    print(f"Model Size: {sum(mds_sz)/1024/1024/1024} GB")
+    opts =[optim.Adam(md.parameters(), lr=lr) for md in mds]
+    #cuda=cpu
+    ds = TestDataset(datas, dims)
+    dl = DataLoader(ds, batch)
+    #return
+    loss_fn = torch.nn.MSELoss()
+    print("start train")
+    nets= []
+    for md in mds:
+        nets+=md.nets
+    gmodel = nn.Sequential(*nets)
+    gmodel = gmodel.to(cuda)
+    gopt = optim.Adam(gmodel.parameters(), lr=lr)
+    gmodel.train()
+    #with torch.no_grad():
+    for i in range(trains):
+        total_loss = 0
+        curr=time.time()
+        for dt in dl:
+            dt=dt.to(cuda)
+            gopt.zero_grad()
+            out = gmodel(dt)
+            loss = loss_fn(out, dt)
+            print(f"loss: {loss, type(loss)}")
+            loss.backward()
+            gopt.step()
+            total_loss+=loss.item()
+        sec = time.time()-curr
+        print("train:", i, "loss:", total_loss/len(dl), "time:", sec)
+    del gmodel,gopt
+    torch.cuda.empty_cache()
+    input("start middle:")
+    md = CacheModel(cuda, cpu, mds, opts, win_size, fc_opt)
+    md.nfc("train")
+    #with torch.no_grad():
+    for i in range(trains):
+        total_loss = 0
+        curr=time.time()
+        for dt in dl:
+            dt=dt.to(cuda)
+            [opt.zero_grad() for opt in opts]
+            out = md.do_forward(dt)
+            loss = loss_fn(out, dt)
+            print(f"loss: {loss, type(loss)}")
+            md.do_backward(lambda : loss.backward())
+            total_loss+=loss.item()
+        sec = time.time()-curr
+        print("train:", i, "loss:", total_loss/len(dl), "time:", sec)
+
+    
+
+pass
+test()

buildz-0.6.60/buildz/gpuz/test/test_middle_conv1.py

@@ -0,0 +1,120 @@
+#
+
+import sys
+from buildz.gpuz.torch import CacheModel
+import torch,time
+from torch import nn,optim
+from torch.utils.data import DataLoader, Dataset
+cpu = torch.device('cpu')
+cuda = cpu
+if torch.cuda.is_available():
+    cuda = torch.device('cuda')
+def sz(tensor):
+    return tensor.element_size()*tensor.nelement()
+class ConvModel(nn.Module):
+    def __init__(self, dims, num, ins_channels, middle_channels):
+        super().__init__()
+        nets=[]
+        for i in range(num):
+            nets.append(nn.Conv2d(ins_channels, middle_channels, 5, padding=2))
+            nets.append(nn.Conv2d(middle_channels, ins_channels, 5, padding=2))
+            nets.append(nn.LeakyReLU())
+        print(f"nets:{len(nets)}")
+        self.nets = nn.Sequential(*nets)
+    def forward(self, inputs):
+        return self.nets(inputs)
+    def size(self):
+        total = 0.0
+        for net in self.nets:
+            if not hasattr(net, "weight"):
+                continue
+            w = net.weight
+            b = net.bias
+            total+=sz(w)+sz(b)
+        return total
+
+pass
+class TestDataset(Dataset):
+    def __init__(self, n, dims, channels):
+        self.n = n
+        self.dims = dims
+        self.datas = torch.rand(n, channels, dims,dims)
+        print(f"data size: {sz(self.datas)/1024/1024/1024} GB")
+    def __len__(self):
+        return self.n
+    def __getitem__(self, i):
+        return self.datas[i]
+        return torch.rand(self.dims)
+
+pass
+def fc_opt(net, opt):
+    torch.nn.utils.clip_grad_norm_(net.parameters(), max_norm=1.0)
+    opt.step()
+def test():
+    nets=2
+    channels=30
+    middle_channels = 60
+    dims=512
+    trains = 5
+    datas = 6
+    batch=2
+    lr=0.0001
+    win_size=3
+    num_conv = 11
+    num_ln = 3
+    mds = [ConvModel(dims, nets, channels, middle_channels) for i in range(num_conv)]
+    mds_sz = [md.size() for md in mds]
+    print(f"Model Size: {sum(mds_sz)/1024/1024/1024} GB")
+    opts =[optim.Adam(md.parameters(), lr=lr) for md in mds]
+    #cuda=cpu
+    ds = TestDataset(datas, dims, channels)
+    dl = DataLoader(ds, batch)
+    #return
+    loss_fn = torch.nn.MSELoss()
+    print("start train")
+    # nets= []
+    # for md in mds:
+    #     nets+=md.nets
+    # gmodel = nn.Sequential(*nets)
+    # gmodel = gmodel.to(cuda)
+    # gopt = optim.Adam(gmodel.parameters(), lr=lr)
+    # gmodel.train()
+    # #with torch.no_grad():
+    # for i in range(trains):
+    #     total_loss = 0
+    #     curr=time.time()
+    #     for dt in dl:
+    #         dt=dt.to(cuda)
+    #         gopt.zero_grad()
+    #         out = gmodel(dt)
+    #         loss = loss_fn(out, dt)
+    #         print(f"loss: {loss, type(loss)}")
+    #         loss.backward()
+    #         gopt.step()
+    #         total_loss+=loss.item()
+    #     sec = time.time()-curr
+    #     print("train:", i, "loss:", total_loss/len(dl), "time:", sec)
+    # del gmodel,gopt
+    # torch.cuda.empty_cache()
+    # input("start middle:")
+    md = CacheModel(cuda, cpu, mds, opts, win_size, fc_opt)
+    md.nfc("train")
+    #with torch.no_grad():
+    for i in range(trains):
+        total_loss = 0
+        curr=time.time()
+        for dt in dl:
+            dt=dt.to(cuda)
+            [opt.zero_grad() for opt in opts] #这一步不必也扔gpu里计算吧，直接这样写了
+            out = md.do_forward(dt)
+            loss = loss_fn(out, dt)
+            print(f"loss: {loss, type(loss)}")
+            md.do_backward(lambda : loss.backward())
+            total_loss+=loss.item()
+        sec = time.time()-curr
+        print("train:", i, "loss:", total_loss/len(dl), "time:", sec)
+
+    
+
+pass
+test()

buildz-0.6.60/buildz/gpuz/torch/__init__.py

@@ -0,0 +1,8 @@
+#coding=utf-8
+
+__version__="0.0.1"
+
+# 小号多
+__author__ = "Zzz, emails: 1174534295@qq.com, 1309458652@qq.com"
+
+from .middlez import CacheModel

buildz-0.6.60/buildz/gpuz/torch/middlez.py

@@ -0,0 +1,181 @@
+#
+import torch
+from torch import nn
+import threading as th
+class CacheModel:
+    '''
+        用处：显存不够，同时模型可以拆成多个小模型线性连接的时候，可以用本代码，本代码会在forward和backward的时候自动把小的多层网络轮流放到gpu里计算，计算完再转cpu里
+        需要使用者手动将多层网络拆分成多个更小一点的多层网络
+        测试代码见test_moddle_conv1.py
+        大概有纯显卡二分之一到三分之一的性能，起码比cpu好，尤其是进行卷积计算，比cpu好太多
+        代码例子:
+        
+        from buildz.gpuz.torch import CacheModel
+        from torch import nn,optim
+        model1 = nn.Sequential(*[nn.Linear(1024,1024) for i in range(10)])
+        model2 = nn.Sequential(*[nn.Linear(1024,1024) for i in range(10)])
+        model3 = nn.Sequential(*[nn.Linear(1024,1024) for i in range(10)])
+        opt1 = optim.Adam(model1.parameters(), lr=0.001)
+        opt2 = optim.Adam(model2.parameters(), lr=0.001)
+        opt3 = optim.Adam(model3.parameters(), lr=0.001)
+        models = [model1,model2,model3]
+        opts = [opt1,opt2,opt3]
+        loss_fn = torch.nn.MSELoss()
+        def opt_step(net, opt):
+            # 如果模型只是用来测试，不做训练，可以不传该函数，同时opts传入空就可以
+            # 对模型的一些其他优化，可以写可以不写，主要是调用opt.step()进行当前小模型的模型训练
+            # torch.nn.utils.clip_grad_norm_(net.parameters(), max_norm=1.0)
+            opt.step()
+        cmodel = CacheModel(torch.device('cuda'), torch.device('cpu'),models,opts,3,opt_step)
+
+        # 训练:
+        [md.train() for md in models]
+        for inputs,targets in dataloader: #批量数据集，这个自己实现
+            [opt.zero_grad() for opt in opts]
+            outs = cmodel.do_forward(inputs)
+            loss = loss_fn(outs, targets)
+            cmodel.do_backward(lambda: loss.backward())
+            # opt.step()在do_backward里会自动调用
+            print(loss.item())
+
+        # 测试:
+        with torch.no_grad():
+            outputs = cmodel.do_forward(inputs)
+        print(outputs)
+    '''
+    def __init__(self, gdv, cdv, nets, opts, win_size = 1, backward_deal = None):
+        '''
+            gdv: 显卡设备，应该传入torch.device('cuda')
+            cdv: CPU设备，应该传入torch.device('cpu')
+            gdv和cdv如果都传入torch.device('cpu')，则是完全CPU存储和计算
+                如果都传入torch.device('cuda')，则是完全显卡存储和计算
+        '''
+        self.gdv = gdv
+        self.cdv = cdv
+        # event和condition未使用，本来打算做成多线程，但python线程一次只能有一个在运行，抢占有点严重，待修改
+        self.event = th.Event()
+        self.condition=th.Condition()
+        [net.register_full_backward_hook(self.hook_backward) for net in nets]
+        self.nets = nets
+        self.size = len(nets)
+        self.ctxs = [[] for i in range(self.size)]
+        self.size_1 = self.size-1
+        self.opts = opts
+        self.win_size = win_size
+        self.backward_deal = backward_deal
+        self.base = -1
+        self.curr = 0
+        self.last = -1
+        self.running = False
+    def hook_pack(self, dt):
+        # forward时候为了后面计算梯度存的缓存，放到列表里方便转cpu和gpu
+        self.ctxs[self.curr].append(dt)
+        return len(self.ctxs[self.curr])-1
+    def hook_unpack(self, x):
+        dt = self.ctxs[self.curr][x]
+        return dt
+    def nfc(self, fc, *a,**b):
+        [getattr(net, fc)(*a,**b) for net in self.nets]
+    def reset(self):
+        for i in range(self.base,self.last+1):
+            self.nets[i].to(self.cdv)
+            self.ctxs_to(i, self.cdv)
+        self.base,self.last=-1,-1
+    def ctxs_to(self, i, dv):
+        if dv is None:
+            self.ctxs[i] = []
+        else:
+            self.ctxs[i] = [k.to(dv) for k in self.ctxs[i]]
+    def copy_backward(self):
+        if self.last<self.curr:
+            self.reset()
+        if self.base==0:
+            return False
+        if self.last<0:
+            self.nets[self.size_1].to(self.gdv)
+            self.last = self.size_1
+            self.base = self.size_1
+        diff = self.win_size-(self.last-self.base+1)
+        diff = min(diff, self.base)
+        for i in range(diff):
+            self.nets[self.base-1].to(self.gdv)
+            self.ctxs_to(self.base-1, self.gdv)
+            self.base-=1
+        rels = self.last-self.curr
+        for i in range(rels):
+            self.nets[self.last].to(self.cdv)
+            self.ctxs_to(self.last, None)
+            self.last-=1
+        return True
+    def copy_forward(self):
+        if self.base>self.curr:
+            self.reset()
+        if self.last==self.size_1:
+            return False
+        if self.base<0:
+            self.nets[0].to(self.gdv)
+            self.base=0
+            self.last=0
+        diff = self.win_size-(self.last-self.base+1)
+        diff = min(diff, self.size_1-self.last)
+        for i in range(diff):
+            self.nets[self.last+1].to(self.gdv)
+            self.last+=1
+        rels = self.curr-self.base
+        for i in range(rels):
+            self.nets[self.base].to(self.cdv)
+            self.ctxs_to(self.base, self.cdv)
+            self.base+=1
+        return True
+    def th_copy_forward(self):
+        while self.copy_forward():
+            self.event.set()
+        self.running = False
+    def th_copy_backward(self):
+        while self.copy_backward():
+            self.event.set()
+    def wait(self):
+        with self.condition:
+            self.condition.notify()
+        self.event.wait()
+    def do_forward(self, inputs):
+        # while self.running:
+        #     import time
+        #     time.sleep(0.01)
+        # t = th.Thread(target=self.th_copy_forward, daemon=True)
+        # self.running = True
+        # t.start()
+        self.ctxs = [[] for i in range(self.size)]
+        with torch.autograd.graph.saved_tensors_hooks(self.hook_pack, self.hook_unpack):
+            rst = self.forward(inputs)
+        return rst
+    def forward(self, inputs):
+        for self.curr in range(len(self.nets)):
+            while not (self.base<=self.curr<=self.last):
+                self.copy_forward()
+                #self.wait()
+            inputs = self.nets[self.curr](inputs)
+        return inputs
+    def wrap_backward_deal(self, i):
+        if self.backward_deal is None:
+            return
+        try:
+            self.backward_deal(self.nets[i], self.opts[i])
+        finally:
+            pass
+    def hook_backward(self, model, ins, outs):
+        if self.backward_curr<self.size_1:
+            self.wrap_backward_deal(self.backward_curr+1)
+        self.curr = self.backward_curr
+        while not (self.base<=self.backward_curr<=self.last):
+            #self.wait()
+            self.copy_backward()
+        self.backward_curr-=1
+    def do_backward(self, fc):
+        self.backward_curr=self.curr
+        # t = th.Thread(target=self.th_copy_backward,daemon=True)
+        # t.start()
+        fc()
+        self.wrap_backward_deal(0)
+
+pass

{buildz-0.6.58 → buildz-0.6.60}/buildz/netz/mhttp/__init__.py

@@ -3,3 +3,4 @@ from .caps import CapsDealer,CapsProxy
 from .proxy import ProxyDealer,Proxy
 from .mhttp import *
 from .record import MsgRecord,MsgLog
+from .gateway import GWDealer,Gateway

{buildz-0.6.58 → buildz-0.6.60}/buildz/netz/mhttp/caps.py

@@ -1,5 +1,5 @@
 
-from . import proxy,mhttp
+from . import proxy,mhttp,mhttps
 import socket, threading
 log = mhttp.log
 from buildz import xf
@@ -72,9 +72,7 @@ class CapsDealer(proxy.ProxyDealer):
     def context(self, hostname):
         if hostname not in self.contexts:
             fp_cert, fp_prv, pwd = self.sign(hostname)
-            context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
-            context.load_cert_chain(fp_cert, fp_prv, password=pwd)
-            self.contexts[hostname]=context
+            self.contexts[hostname]=mhttps.load_server_context(fp_cert, fp_prv, pwd)
         return self.contexts[hostname]
     def deal_channel(self, skt_cli, skt_srv):
         #self.wskt.closefile()
@@ -92,7 +90,7 @@ class CapsDealer(proxy.ProxyDealer):
                 line, headers, data_size = mhttp.http_recv(skt_cli)
                 if line is None:
                     continue
-                self.default_deal(skt_cli, line, headers, data_size, skt_srv)
+                self.deals[None](skt_cli, line, headers, data_size, skt_srv)
         except Exception as exp:
             log.debug(f"channel exp: {exp}")
             log.warn(f"traceback: {traceback.format_exc()}")
@@ -110,29 +108,9 @@ class CapsProxy(proxy.Proxy):
         # context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
         # context.load_cert_chain(fp_sign, fp_prv, password=password)
         self.ca = fp_sign, fp_prv, password
-        if cafile is not None or capath is not None or cadata is not None:
-            # 导入根证书，需要单个根证书文件cafile或者根证书文件夹capath或者根证书数据cadata
-            # cadata是证书数据，不清楚能不能多个证书字节码拼在一起
-            srv_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
-            srv_context.load_verify_locations(cafile=cafile, capath=capath, cadata=cadata)
-            srv_context.check_hostname = check_hostname
-        else:
-            # 不会校验服务端https证书是否有效，可能有风险？
-            srv_context = ssl._create_unverified_context(ssl.PROTOCOL_TLS_CLIENT)
-        #self.context = context
-        self.srv_context = srv_context
+        self.srv_context = mhttps.load_verify_context(cafile, capath, cadata,check_hostname)
         if dp_cache is None:
             dp_cache = "./res/certs"
         self.dp_cache = dp_cache
-    def call(self):
-        self.running=True
-        skt = socket.socket()
-        skt.bind(self.addr)
-        skt.listen(self.listen)
-        self.skt = skt
-        while self.running:
-            skt,addr = self.skt.accept()
-            deal = CapsDealer(skt, self.ca, self.srv_context, record=self.record.clone(), dp_cache = self.dp_cache)
-            th = threading.Thread(target=deal,daemon=True)
-            th.start()
-            self.ths.append(th)
+    def make_dealer(self, skt, addr):
+        return CapsDealer(skt, self.ca, self.srv_context, record=self.record.clone(), dp_cache = self.dp_cache)