import logging
|
import multiprocessing
|
import random
|
import threading
|
import time
|
|
import zmq
|
|
import constant
|
from huaxin_client.communication.l2_communication import L2ChannelCommunicationParams, L2SharedMemoryDataUtil
|
from log_module.log import logger_debug
|
|
|
class L2Strategy:
|
|
def __init__(self, commu_params):
|
self.context = zmq.Context()
|
self.commu_params = commu_params
|
|
def rec_delegate_data(self, delegate_ipc_addr, shared_memory):
|
socket = self.context.socket(zmq.REP)
|
socket.bind(delegate_ipc_addr)
|
while True:
|
msg = socket.recv_json()
|
try:
|
use_time = (time.time() - msg['time']) * 1000
|
decoded_data, decoded_use_time = L2SharedMemoryDataUtil.get_data(shared_memory)
|
print(f"获取到逐笔委托数据: 数据长度：{len(decoded_data)} 通信耗时：{use_time}ms 解码耗时:{decoded_use_time}s")
|
if use_time > 1:
|
logger_debug.info(f"委托通信耗时：{use_time}")
|
except Exception as e:
|
logging.exception(e)
|
finally:
|
socket.send_string("SUCCESS")
|
|
def rec_deal_data(self, deal_ipc_addr, shared_memory):
|
socket = self.context.socket(zmq.REP)
|
socket.bind(deal_ipc_addr)
|
while True:
|
msg = socket.recv_json()
|
try:
|
use_time = (time.time() - msg['time']) * 1000
|
decoded_data, decoded_use_time = L2SharedMemoryDataUtil.get_data(shared_memory)
|
print(f"获取到逐笔成交数据: 数据长度：{len(decoded_data)} 通信耗时：{use_time}ms 解码耗时:{decoded_use_time}s")
|
if use_time > 1:
|
logger_debug.info(f"成交通信耗时：{use_time}")
|
except Exception as e:
|
logging.exception(e)
|
finally:
|
socket.send_string("SUCCESS")
|
|
def run(self):
|
for param in self.commu_params:
|
threading.Thread(target=self.rec_delegate_data,
|
args=(param.delegate_ipc_addr, param.delegate_data_shared_memory,), daemon=True).start()
|
threading.Thread(target=self.rec_deal_data, args=(param.deal_ipc_addr, param.deal_data_shared_memory,),
|
daemon=True).start()
|
while True:
|
time.sleep(100)
|
|
|
class L2DataCollector:
|
|
def __init__(self, commu_params):
|
self.context = zmq.Context()
|
self.commu_params = commu_params
|
|
def send_delegate_data(self, delegate_ipc_addr, shared_memory):
|
socket = self.context.socket(zmq.REQ)
|
socket.connect(delegate_ipc_addr)
|
while True:
|
try:
|
datas = ('000990', 7.52, 400, 93000030, 2012, 380422, 380421, 375477, '1') * 150
|
L2SharedMemoryDataUtil.set_data(datas, shared_memory)
|
socket.send_json({'data': [], "time": time.time()})
|
response = socket.recv_string()
|
except Exception as e:
|
logging.exception(e)
|
finally:
|
t = random.randint(0, 100)
|
time.sleep(t / 1000)
|
|
def send_deal_data(self, deal_ipc_addr, shared_memory):
|
socket = self.context.socket(zmq.REQ)
|
socket.connect(deal_ipc_addr)
|
while True:
|
try:
|
datas = ('888888', 7.52, 400, 93000030, 2012, 380422, 380421, 375477, '1') * 150
|
use_time = L2SharedMemoryDataUtil.set_data(datas, shared_memory)
|
if use_time > 0.0005:
|
logger_debug.info(f"数据装载耗时：{use_time}")
|
|
socket.send_json({'data': [], "time": time.time()})
|
response = socket.recv_string()
|
except Exception as e:
|
logging.exception(e)
|
finally:
|
t = random.randint(0, 100)
|
time.sleep(t / 1000)
|
|
def run(self):
|
for param in self.commu_params:
|
threading.Thread(target=self.send_delegate_data,
|
args=(param.delegate_ipc_addr, param.delegate_data_shared_memory,),
|
daemon=True).start()
|
threading.Thread(target=self.send_deal_data, args=(param.deal_ipc_addr, param.deal_data_shared_memory,),
|
daemon=True).start()
|
while True:
|
time.sleep(100)
|
|
|
if __name__ == "__main__":
|
channel_count = 100
|
params = []
|
for i in range(0, channel_count):
|
delegate_data_array = L2SharedMemoryDataUtil.create_shared_memory()
|
deal_data_array = L2SharedMemoryDataUtil.create_shared_memory()
|
param = L2ChannelCommunicationParams(
|
delegate_ipc_addr=f"ipc://order_{i}.ipc",
|
deal_ipc_addr=f"ipc://deal_{i}.ipc",
|
delegate_data_shared_memory=delegate_data_array,
|
deal_data_shared_memory=deal_data_array)
|
if constant.is_windows():
|
param.delegate_ipc_addr = f"tcp://127.0.0.1:{15000 + i}"
|
param.deal_ipc_addr = f"tcp://127.0.0.1:{16000 + i}"
|
params.append(param)
|
strategy = L2Strategy(params)
|
dataCollector = L2DataCollector(params)
|
strategyProcess = multiprocessing.Process(target=strategy.run, args=())
|
l2Process = multiprocessing.Process(target=dataCollector.run, args=())
|
strategyProcess.start()
|
l2Process.start()
|
while True:
|
time.sleep(100)
|
|
if __name__ == "__main__1":
|
datas = ('000990', 7.52, 400, 93000030, 2012, 380422, 380421, 375477, '1') * 100
|
print(datas)
|
