You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
166 lines
7.4 KiB
166 lines
7.4 KiB
import logging
|
|
import uuid
|
|
import random
|
|
import threading
|
|
from fe.access import book
|
|
from fe.access.new_seller import register_new_seller
|
|
from fe.access.new_buyer import register_new_buyer
|
|
from fe.access.buyer import Buyer
|
|
from fe import conf
|
|
|
|
|
|
class NewOrder:
|
|
def __init__(self, buyer: Buyer, store_id, book_id_and_count):
|
|
self.buyer = buyer
|
|
self.store_id = store_id
|
|
self.book_id_and_count = book_id_and_count
|
|
|
|
def run(self) -> (bool, str):
|
|
code, order_id = self.buyer.new_order(self.store_id, self.book_id_and_count)
|
|
return code == 200, order_id
|
|
|
|
|
|
class Payment:
|
|
def __init__(self, buyer:Buyer, order_id):
|
|
self.buyer = buyer
|
|
self.order_id = order_id
|
|
|
|
def run(self) -> bool:
|
|
code = self.buyer.payment(self.order_id)
|
|
return code == 200
|
|
|
|
|
|
class Workload:
|
|
def __init__(self):
|
|
self.uuid = str(uuid.uuid1())
|
|
self.book_ids = []
|
|
self.buyer_ids = []
|
|
self.store_ids = []
|
|
self.book_db = book.BookDB(conf.Use_Large_DB)
|
|
self.row_count = self.book_db.get_book_count()
|
|
|
|
self.book_num_per_store = conf.Book_Num_Per_Store
|
|
if self.row_count < self.book_num_per_store:
|
|
self.book_num_per_store = self.row_count
|
|
self.store_num_per_user = conf.Store_Num_Per_User
|
|
self.seller_num = conf.Seller_Num
|
|
self.buyer_num = conf.Buyer_Num
|
|
self.session = conf.Session
|
|
self.stock_level = conf.Default_Stock_Level
|
|
self.user_funds = conf.Default_User_Funds
|
|
self.batch_size = conf.Data_Batch_Size
|
|
self.procedure_per_session = conf.Request_Per_Session
|
|
|
|
self.n_new_order = 0
|
|
self.n_payment = 0
|
|
self.n_new_order_ok = 0
|
|
self.n_payment_ok = 0
|
|
self.time_new_order = 0
|
|
self.time_payment = 0
|
|
self.lock = threading.Lock()
|
|
# 存储上一次的值，用于两次做差
|
|
self.n_new_order_past = 0
|
|
self.n_payment_past = 0
|
|
self.n_new_order_ok_past = 0
|
|
self.n_payment_ok_past = 0
|
|
|
|
def to_seller_id_and_password(self, no: int) -> (str, str):
|
|
return "seller_{}_{}".format(no, self.uuid), "password_seller_{}_{}".format(no, self.uuid)
|
|
|
|
def to_buyer_id_and_password(self, no: int) -> (str, str):
|
|
return "buyer_{}_{}".format(no, self.uuid), "buyer_seller_{}_{}".format(no, self.uuid)
|
|
|
|
def to_store_id(self, seller_no: int, i):
|
|
return "store_s_{}_{}_{}".format(seller_no, i, self.uuid)
|
|
|
|
def gen_database(self):
|
|
logging.info("load data")
|
|
for i in range(1, self.seller_num + 1):
|
|
user_id, password = self.to_seller_id_and_password(i)
|
|
seller = register_new_seller(user_id, password)
|
|
for j in range(1, self.store_num_per_user + 1):
|
|
store_id = self.to_store_id(i, j)
|
|
code = seller.create_store(store_id)
|
|
assert code == 200
|
|
self.store_ids.append(store_id)
|
|
row_no = 0
|
|
|
|
while row_no < self.book_num_per_store:
|
|
books = self.book_db.get_book_info(row_no, self.batch_size)
|
|
if len(books) == 0:
|
|
break
|
|
for bk in books:
|
|
code = seller.add_book(store_id, self.stock_level, bk)
|
|
assert code == 200
|
|
if i == 1 and j == 1:
|
|
self.book_ids.append(bk.id)
|
|
row_no = row_no + len(books)
|
|
logging.info("seller data loaded.")
|
|
for k in range(1, self.buyer_num + 1):
|
|
user_id, password = self.to_buyer_id_and_password(k)
|
|
buyer = register_new_buyer(user_id, password)
|
|
buyer.add_funds(self.user_funds)
|
|
self.buyer_ids.append(user_id)
|
|
logging.info("buyer data loaded.")
|
|
|
|
def get_new_order(self) -> NewOrder:
|
|
n = random.randint(1, self.buyer_num)
|
|
buyer_id, buyer_password = self.to_buyer_id_and_password(n)
|
|
store_no = int(random.uniform(0, len(self.store_ids) - 1))
|
|
store_id = self.store_ids[store_no]
|
|
books = random.randint(1, 10)
|
|
book_id_and_count = []
|
|
book_temp = []
|
|
for i in range(0, books):
|
|
book_no = int(random.uniform(0, len(self.book_ids) - 1))
|
|
book_id = self.book_ids[book_no]
|
|
if book_id in book_temp:
|
|
continue
|
|
else:
|
|
book_temp.append(book_id)
|
|
count = random.randint(1, 10)
|
|
book_id_and_count.append((book_id, count))
|
|
b = Buyer(url_prefix=conf.URL, user_id=buyer_id, password=buyer_password)
|
|
new_ord = NewOrder(b, store_id, book_id_and_count)
|
|
return new_ord
|
|
|
|
def update_stat(self, n_new_order, n_payment,
|
|
n_new_order_ok, n_payment_ok,
|
|
time_new_order, time_payment):
|
|
# 获取当前并发数
|
|
thread_num = len(threading.enumerate())
|
|
# 加索
|
|
self.lock.acquire()
|
|
self.n_new_order = self.n_new_order + n_new_order
|
|
self.n_payment = self.n_payment + n_payment
|
|
self.n_new_order_ok = self.n_new_order_ok + n_new_order_ok
|
|
self.n_payment_ok = self.n_payment_ok + n_payment_ok
|
|
self.time_new_order = self.time_new_order + time_new_order
|
|
self.time_payment = self.time_payment + time_payment
|
|
# 计算这段时间内新创建订单的总数目
|
|
n_new_order_diff = self.n_new_order - self.n_new_order_past
|
|
# 计算这段时间内新付款订单的总数目
|
|
n_payment_diff = self.n_payment - self.n_payment_past
|
|
|
|
if self.n_payment != 0 and self. n_new_order != 0 \
|
|
and (self.time_payment + self.time_new_order):
|
|
# TPS_C(吞吐量):成功创建订单数量/(提交订单时间/提交订单并发数 + 提交付款订单时间/提交付款订单并发数)
|
|
# NO=OK:新创建订单数量
|
|
# Thread_num:以新提交订单的数量作为并发数(这一次的TOTAL-上一次的TOTAL)
|
|
# TOTAL:总提交订单数量
|
|
# LATENCY:提交订单时间/处理订单笔数(只考虑该线程延迟，未考虑并发)
|
|
# P=OK:新创建付款订单数量
|
|
# Thread_num:以新提交付款订单的数量作为并发数(这一次的TOTAL-上一次的TOTAL)
|
|
# TOTAL:总付款提交订单数量
|
|
# LATENCY:提交付款订单时间/处理付款订单笔数(只考虑该线程延迟，未考虑并发)
|
|
logging.info("TPS_C={}, NO=OK:{} Thread_num:{} TOTAL:{} LATENCY:{} , P=OK:{} Thread_num:{} TOTAL:{} LATENCY:{}".format(
|
|
int(self.n_new_order_ok / (self.time_payment / n_payment_diff + self.time_new_order / n_new_order_diff)), # 吞吐量:完成订单数/((付款所用时间+订单所用时间)/并发数)
|
|
self.n_new_order_ok, n_new_order_diff, self.n_new_order, self.time_new_order / self.n_new_order, # 订单延迟:(创建订单所用时间/并发数)/新创建订单数
|
|
self.n_payment_ok, n_payment_diff, self.n_payment, self.time_payment / self.n_payment # 付款延迟:(付款所用时间/并发数)/付款订单数
|
|
))
|
|
self.lock.release()
|
|
# 旧值更新为新值，便于下一轮计算
|
|
self.n_new_order_past = self.n_new_order
|
|
self.n_payment_past = self.n_payment
|
|
self.n_new_order_ok_past = self.n_new_order_ok
|
|
self.n_payment_ok_past = self.n_payment_ok
|