class queueManager:
def __init__(self, inputmbrs):
self.qu1 = kNNLRUCache(100)
self.qu2 = LRUCache(100)
self.mbrs = inputmbrs
self.hit1 = 0
self.miss1 = 0
self.hit2 = 0
self.miss2 = 0
def getSpatial(self, x, y, r):
for mbr in self.mbrs:
if mbr.dist2p(x, y) < r:
# print("checking" + str(mbr))
result1 = self.qu1.get(str(mbr))
if result1 == -1:
self.miss1 += 1
self.qu1.set(str(mbr), 0)
else:
self.hit1 += 1
result2 = self.qu2.get(str(mbr))
if result2 == -1:
self.miss2 += 1
self.qu2.set(str(mbr), 0)
else:
self.hit2 += 1
if result1 != result2:
print("different!")
def test_operation2(self):
cache = LRUCache(1)
cache.set(2, 1, 11)
self.assertEqual(cache.get(2), 1)
cache.set(3, 2, 11)
self.assertEqual(cache.get(2), -1)
self.assertEqual(cache.get(3), 2)
def test_operation1(self):
cache = LRUCache(2)
cache.set(2, 1, 11)
cache.set(1, 1, 11)
self.assertEqual(cache.get(2), 1)
cache.set(4, 1, 11)
self.assertEqual(cache.get(1), -1)
self.assertEqual(cache.get(2), 1)
def main():
global tablet
global normal_set
global TP
global FP
global FN
global label_y
global predict_y
file_dir = '/cbs_trace1/sample_6/'
#load Cache
MemoryCache = LRUCache(memory_size)
SSDCache = LRUCache(cache_size)
#load Classifier
clf = Classifier()
current_time = 1538323200
last = 0
for i in range(1, 31):
ssd_hit_num = 0
memory_hit_num = 0
total_read = 0
total_write = 0
memory_write_num = 0
memory_write_hit = 0
ssd_write_num = 0
hdd_write_num = 0
predict_time = 0
predict_cnt = 0
data_x = []
data_y = []
if clf.load("%d.clf" % (last)):
predict_flag = 1
else:
predict_flag = 0
print('----------------------------------')
cudate = time.strftime("%Y-%m-%d", time.localtime(current_time))
print(cudate)
current_time += 86400
print('----------------------------------')
file_name = file_dir + str(i)
f = open(file_name, "r")
for line in f.readlines():
io_record = line.split(",")
#update tablet
key = io_record[4][:-2] + ',' + str(int(io_record[1]) >> 11)
if key in tablet:
a = tablet[key]
else:
a = [0 for i in range(0, feature_num)]
tablet[key] = a
if int(io_record[3]) == 1:
a[info_table['WriteSize']] += int(io_record[2])
a[info_table['WriteCnt']] += 1
if a[info_table['LastWrite']] != 0:
a[info_table['WriteInterval']] += abs(
int(io_record[0]) - a[info_table['LastWrite']])
a[info_table['LastWrite']] = int(io_record[0])
if int(io_record[2]) > 64:
a[info_table['BigWrite']] += 1
elif int(io_record[2]) <= 8:
a[info_table['SmallWrite']] += 1
else:
a[info_table['ReadSize']] += int(io_record[2])
a[info_table['ReadCnt']] += 1
if a[info_table['LastRead']] != 0:
a[info_table['ReadInterval']] += abs(
int(io_record[0]) - a[info_table['LastRead']])
a[info_table['LastRead']] = int(io_record[0])
if int(io_record[2]) > 64:
a[info_table['BigRead']] += 1
elif int(io_record[2]) <= 8:
a[info_table['SmallRead']] += 1
#update Cache
block = io_record[4][:-2] + ',' + str(int(io_record[1]) >> 6)
if int(io_record[3]) == 1:
#write
total_write += 1
if MemoryCache.get(block) != None:
memory_write_num += 1
memory_write_hit += 1
else:
#reach condition to flush, flush first!
flush_data = MemoryCache.flush()
if flush_data != None:
feature_tmp = []
flush_key = []
for key in flush_data:
flush_key.append(key[0])
feature_tmp.append(process_eviction(key, 0)[0])
if predict_flag == 1:
oldtime = datetime.now()
rst = clf.predict(feature_tmp)
newtime = datetime.now()
predict_cnt += len(flush_key)
predict_time += int(
(newtime - oldtime).microseconds)
for key, ft in zip(flush_key, rst):
tablet_key = "%s,%d" % (key.split(
",")[0], int(key.split(",")[1]) >> 5)
if key in SSDCache.cache:
ssd_write_num += 1
else:
if ft == 1:
#only write
hdd_write_num += 1
tablet[tablet_key][
info_table['Predict']] = 1
else:
tablet[tablet_key][
info_table['Predict']] = 2
ssd_write_num += 1
ssd_evict = SSDCache.set(key, 1)
if ssd_evict != None:
hdd_write_num += 1
label = process_eviction(
ssd_evict, 1)
data_x.append(label[0])
data_y.append(label[1])
else:
for key in flush_key:
ssd_write_num += 1
ssd_evict = SSDCache.set(key, 1)
if ssd_evict != None:
hdd_write_num += 1
label = process_eviction(ssd_evict, 1)
data_x.append(label[0])
data_y.append(label[1])
MemoryCache.set(block, 1)
else:
#read
total_read += 1
if MemoryCache.get(block) != None:
#hit
memory_hit_num += 1
else:
if SSDCache.get(block) != None:
#hit
ssd_hit_num += 1
a[info_table['Hit']] += 1
else:
ssd_evict = SSDCache.set(block, 1)
ssd_write_num += 1
if ssd_evict != None:
hdd_write_num += 1
label = process_eviction(ssd_evict, 1)
data_x.append(label[0])
data_y.append(label[1])
print("SSD footprint : %.2f %%" %
(len(SSDCache.cache) * 100 / cache_size))
print("Memory footprint : %.2f %%" %
(len(MemoryCache.cache) * 100 / memory_size))
print("memory_write : %.2f %%" %
(memory_write_num * 100 / total_write))
print("memory_write_hit : %.2f %%" %
(memory_write_hit * 100 / total_write))
print("ssd_write : %.2f %%" % ((ssd_write_num) * 100 / total_write))
print("hdd_write : %.2f %%" % (hdd_write_num * 100 / total_write))
print("Memory Hit Ratio : %.2f %%" %
(memory_hit_num * 100 / total_read))
print("SSD Hit Ratio : %.2f %%" %
((memory_hit_num + ssd_hit_num) * 100 / total_read))
oldtime = datetime.now()
#training model for next day
last = i
#save Classifier
if len(data_x) > 0:
clf = Classifier()
clf.load("%d.clf" % (last))
clf.fit(data_x, data_y)
clf.save("%d.clf" % (last))
newtime = datetime.now()
train_time = int((newtime - oldtime).microseconds)
#result
file = 'result/hwp_result'
f = open(file, 'a+')
#time,memory_write,ssd_write,hdd_write,ssd_write_ratio,hdd_write_ratio,memory_hit,ssd_hit,accuracy,recall,predict_time,auc,train_time,recall2,positive_ratio
if TP + FP == 0:
f.write(
"%d\t%d\t%d\t%d\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%.4f\t%d\t%.2f\t%.2f\n"
% (current_time - 86400, total_write, ssd_write_num,
hdd_write_num, ssd_write_num * 100 / total_write,
hdd_write_num * 100 / total_write,
memory_hit_num * 100 / total_read,
(memory_hit_num + ssd_hit_num) * 100 / total_read, 0, 0, 0,
0, train_time, 0, 0))
else:
auc = metrics.roc_auc_score(label_y, predict_y)
total = len(label_y)
right = 0
pos = 0
t1 = 0
for l, p in zip(label_y, predict_y):
if l == p:
right += 1
if l == 1:
pos += 1
if p == 1:
t1 += 1
f.write(
"%d\t%d\t%d\t%d\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%.4f\t%d\t%.2f\t%.2f\n"
% (current_time - 86400, total_write, ssd_write_num,
hdd_write_num, ssd_write_num * 100 / total_write,
hdd_write_num * 100 / total_write,
memory_hit_num * 100 / total_read,
(memory_hit_num + ssd_hit_num) * 100 / total_read,
right * 100 / total, TP * 100 /
(TP + FN), predict_time / predict_cnt, auc, train_time,
t1 * 100 / pos, pos * 100 / total))
f.close()
import time
from LRUCache import LRUCache
"""
TEST #1: INSERT ELEMENTS UNTIL CACHE GETS FULL
"""
print("Test #1: INSERT ELEMENTS UNTIL CACHE GETS FULL.")
capacity = 5
cache_test_1 = LRUCache(capacity)
for key in range(capacity+1):
value = key
cache_test_1.set(key, value)
print(cache_test_1)
print("-----------------------------------------------")
"""
TEST #2: INSERT ELEMENT WHEN CHACHE IS FULL
"""
print("")
print("Test #2: INSERT AN ELEMENT WHEN CACHE IS FULL.")
print("Element with key #1 should be deleted")
extra_element_key = capacity+1 # extra_element equals to 6
extra_element_value = capacity + 1
cache_test_1.set(extra_element_key,extra_element_value)
print(cache_test_1)
print("-----------------------------------------------")
"""
TEST #3: TRYING TO GET AN ELEMENT WHICH IS NOT INSIDE CACHE
"""
class UCAC4:
""" Uses UCAC4 catalog to search ucac4 numbers from coords and vice versa. Ucac4 path can be passed or read from $ucac4_path """
def __init__(self, ucac_path=None):
if ucac_path is None:
try:
ucac_path = Path(os.environ["ucac4_path"])
print("found environ with ucac4 path", ucac_path)
except KeyError:
logging.debug(
"No ucac path passed, and no environment var, using default"
)
ucac_path = Path("./support/ucac4/UCAC4/")
logging.info(f"Ucac path is {ucac_path}")
# star id given by munipack
self.ucac_path = ucac_path
self.zones_cache = LRUCache(capacity=10)
self.bucket_cache = LRUCache(capacity=100000)
self.zone_bucket_cache = LRUCache(capacity=10000)
self.index_cache = None
self.ra_range = 360 * 3600 * 100
# read index file
with open(
str(Path(ucac_path, "u4i", "u4index.unf")), mode="rb"
) as file: # b is important -> binary
self.index_cache = file.read()
self.zone_starformat = "=iiHHBBBbbBBBHHhhbbIHHHBBBBBBHHHHHbbbbbBIBBIHI"
self.zone_star_length = struct.calcsize(self.zone_starformat)
self.unpack_zone_fileformat = struct.Struct(self.zone_starformat).unpack
(
self.result_n0_running_star_number,
self.result_nn_stars_in_bin,
) = UCAC4._get_n0_and_nn(self.index_cache)
def get_zone_filecontent(self, zone: int):
""" gets the content of a zone file, either from disk or from cache"""
result = self.zones_cache.get(zone)
if result != -1:
return result
with open(
str(Path(self.ucac_path, f"u4b/z{zone:03}")), mode="rb"
) as file: # b is important -> binary
result = file.read()
self.zones_cache.set(zone, result)
return result
def get_ucactuple_from_id(self, ucac_id) -> UcacTuple:
""" Given a UCAC ID, return a tuple of (StarTuple, zone, run_nr) """
zone, run_nr = UCAC4.ucac_id_to_zone_and_run_nr(ucac_id)
logging.debug(f"UCAC4 id {zone}, {run_nr}")
return self.get_ucactuples_for_zone_and_runnrs(zone, [run_nr])[0]
def get_ra_dec_from_id(self, ucac4_id) -> Tuple[float, float]:
startuple, _, _ = self.get_ucactuple_from_id(ucac4_id)
ra, dec = UCAC4.get_real_ra_dec(startuple.ra, startuple.spd)
return ra, dec
def index_bin_to_run_nrs(self, zone: int, index_bin: int):
# index = (zone - 1) * 1440 + index_bin
index = (index_bin - 1) * 900 + zone - 1
star_run_nr = self.result_n0_running_star_number[index]
star_count_in_bucket = self.result_nn_stars_in_bin[index]
run_nrs = list(range(star_run_nr, star_run_nr + star_count_in_bucket))
logging.debug(
f"index_bin_to_run_nrs: zone is {zone}, index_bin = {index_bin}, index is {index}. "
f"star_run_nr is {star_run_nr}, count = {star_count_in_bucket}, run nrs: {run_nrs}"
)
return run_nrs
def get_zones_and_index_bins(self, ra, dec, tolerance_deg) -> Dict[int, List[int]]:
logging.debug(f"ra: {ra}, dec: {dec}, tolerance: {tolerance_deg}")
zone = self.get_zone_for_dec(dec - tolerance_deg / 2)
end_zone = self.get_zone_for_dec(dec + tolerance_deg / 2)
# check for zone overlap
zones = list(range(zone, end_zone + 1))
logging.debug(f"get_zones_and_index_bins: Zone range is {zones}")
ra_low = self.ra_bin_index(ra - tolerance_deg / 2) # ra_start in C code
ra_high = self.ra_bin_index(ra + tolerance_deg / 2)
index_bins = list(range(ra_low, ra_high + 1))
logging.debug(f"get_zones_and_index_bins: {ra_low}, {ra_high}, {index_bins}")
return zones, index_bins
def get_ucactuples_for_zone_and_runnrs(
self, zone: int, run_nr_list: List[int]
) -> UcacTupleList:
""" Given a zone and one or more run_nr's, return List of (StarTuple, zone, run_nr) """
stars = []
filecontent = self.get_zone_filecontent(zone)
for run_nr in run_nr_list:
key = (zone, run_nr)
# logging.debug(f"Getting star from zone {zone}, run_nr {run_nr}")
star = self.bucket_cache.get(key)
if star == -1:
result = self.unpack_zone_fileformat(
filecontent[
self.zone_star_length
* (run_nr - 1) : self.zone_star_length
* run_nr
]
)
star = UCAC4.make_startuple(result)
self.bucket_cache.set(key, star)
stars.append((star, zone, run_nr))
# logging.debug(f"read ucac4 star: {star}")
return stars
@staticmethod
def _get_n0_and_nn(index_cache):
index_format = "1296000I"
index_length = struct.calcsize(index_format)
logging.debug(f"index length is {index_length}")
unpack_starformat = struct.Struct(index_format).unpack
result_n0 = unpack_starformat(index_cache[0:index_length])
result_nn = unpack_starformat(index_cache[index_length:])
return result_n0, result_nn
def get_region_minimal_star_tuples(
self, ra: float, dec: float, radius=0.5
) -> List[MinimalStarTuple]:
""" For a given ra/dec and radius, return all ucac4 stars as ('id, ra, dec, mag') """
zones, buckets = self.get_zones_and_index_bins(ra, dec, radius)
result = []
for zone in zones:
for bucket in buckets:
cache_key = (zone, bucket)
ucactuples: UcacTupleList = self.zone_bucket_cache.get(cache_key)
# cache miss
if ucactuples == -1:
ucactuples: UcacTupleList = self.get_ucactuples_for_zone_and_runnrs(
zone, self.index_bin_to_run_nrs(zone, bucket)
)
self.zone_bucket_cache.set(cache_key, ucactuples)
if len(ucactuples) == 0:
logging.debug(f"zone/bucket: {zone}/{bucket}, no stars")
if bucket + 1 not in buckets:
buckets.append(bucket + 1)
logging.debug(f"Appending bucket {bucket+1}")
for ucactuple in ucactuples:
result.append(
MinimalStarTuple(
UCAC4.zone_and_run_nr_to_name(ucactuple[1], ucactuple[2]),
*UCAC4.get_real_ra_dec(ucactuple[0].ra, ucactuple[0].spd),
ucactuple[0].apass_mag_V / 1000,
)
)
return result
def get_sd_from_ra_dec(
self, ra: float, dec: float, tolerance_deg=0.02
) -> StarDescription:
return self.get_star_description_from_tuple(
self.get_ucactuple_from_ra_dec(ra, dec, tolerance_deg)
)
def get_ucactuple_from_ra_dec(
self, ra: float, dec: float, tolerance_deg=0.02
) -> UcacTuple:
logging.debug(
f"get_ucac4_ucactuple_from_ra_dec with ra:{ra}, dec:{dec}, tolerance:{tolerance_deg}"
)
target_np = np.array((ra, dec))
zones, buckets = self.get_zones_and_index_bins(ra, dec, tolerance_deg)
smallest_dist = 1000
best = None
for zone in zones:
for bucket in buckets:
cache_key = (zone, bucket)
ucactuples: UcacTupleList = self.zone_bucket_cache.get(cache_key)
# cache miss
if ucactuples == -1:
ucactuples: UcacTupleList = self.get_ucactuples_for_zone_and_runnrs(
zone, self.index_bin_to_run_nrs(zone, bucket)
)
self.zone_bucket_cache.set(cache_key, ucactuples)
################ DEBUG
if len(ucactuples) > 0:
radecs = [
self.get_real_ra_dec(x[0].ra, x[0].spd) for x in ucactuples
]
ras = [x[0] for x in radecs]
decs = [x[1] for x in radecs]
logging.debug(
f"zone/bucket: {zone}/{bucket}, Searching between {min(ras)}, {max(ras)}, {min(decs)}, {max(decs)}"
)
else:
logging.debug(f"zone/bucket: {zone}/{bucket}, no stars")
if bucket + 1 not in buckets:
buckets.append(bucket + 1)
logging.debug(f"Appending bucket {bucket+1}")
################ DEBUG
for ucactuple in ucactuples:
dist = np.linalg.norm(
np.array(
(UCAC4.get_real_ra_dec(ucactuple[0].ra, ucactuple[0].spd))
- target_np
)
)
# logging.debug(f"magj: {sd[0].mag_j}")
if dist < smallest_dist:
smallest_dist = dist
best = ucactuple
if best is None:
logging.warning(
f"Did not find a UCAC4 match for {ra}, {dec}, {tolerance_deg}. Buckets: {buckets}, "
f"zones: {zones},smallest dist: {smallest_dist}"
)
return best
logging.debug(f"Best distance is: {smallest_dist}, {best}")
return best
@staticmethod
def get_zone_for_dec(dec: float, zone_height: float = 0.2) -> int:
dec_0 = decimal.Decimal(dec) + decimal.Decimal(90.0)
result = min(900, max(1, int(dec_0 / decimal.Decimal(zone_height)) + 1))
logging.debug(
f"get_zone_for_dec: dec {dec}, height:{zone_height}, dec0 {dec_0}, result {result}"
)
return result
@staticmethod
def ra_bin_index(ra: float):
"""index for bins along RA (1 to 1440)"""
index = math.ceil(decimal.Decimal(ra) * decimal.Decimal(4)) # 1440/360
logging.debug(
f"ra_bin_index: ra {ra}, index {index}, rawindex: {decimal.Decimal(ra) * decimal.Decimal(4)}"
)
return max(1, index)
@staticmethod
def ucac_id_to_zone_and_run_nr(ucac_id: str):
full_id = ucac_id[6:]
zone = int(full_id[:3])
run_nr = int(full_id[4:].lstrip("0"))
return zone, run_nr
@staticmethod
def zone_and_run_nr_to_name(zone: int, run_nr: int):
return f"UCAC4 {zone:03}-{run_nr:06}"
def get_star_description_from_id(self, ucac4_id) -> StarDescription:
return UCAC4.get_star_description_from_tuple(
self.get_ucactuple_from_id(ucac4_id)
)
@staticmethod
def get_star_descriptions_from_tuples(
ucactuples: UcacTupleList,
) -> List[StarDescription]:
return [
UCAC4.get_star_description_from_tuple(ucactuple) for ucactuple in ucactuples
]
@staticmethod
def get_star_description_from_tuple(ucactuple: UcacTuple) -> StarDescription:
startuple, zone, run_nr = ucactuple
ra, dec = UCAC4.get_real_ra_dec(startuple.ra, startuple.spd)
coords=SkyCoord(ra, dec, unit="deg")
vmag=startuple.apass_mag_V / 1000
vmag_err=abs(startuple.apass_mag_sigma_V / 100)
aavso_id=UCAC4.zone_and_run_nr_to_name(zone, run_nr)
sd = StarDescription(
coords=coords,
vmag=vmag,
vmag_err=vmag_err,
aavso_id=aavso_id,
)
do_calibration.add_catalog_data_to_sd(
sd,
vmag,
vmag_err,
aavso_id,
"UCAC4",
coords,
extradata=ucactuple[0]._asdict() # get the StarTuple from the UcacTuple
)
return sd
@staticmethod
def get_real_ra_dec(ra, spd) -> Tuple[float, float]:
# return ra / 1000 / 3600, (spd - 324000000) / 1000 / 3600
divisor = decimal.Decimal(3600000)
return (
float(decimal.Decimal(ra) / divisor),
float(decimal.Decimal(spd - 324000000) / divisor),
)
@staticmethod
def make_startuple(result: List) -> StarTuple:
star = StarTuple._make(result)
star = star._replace(ra_sigma=star.ra_sigma + 128)
star = star._replace(dec_sigma=star.dec_sigma + 128)
star = star._replace(pm_ra_sigma=star.pm_ra_sigma + 128)
star = star._replace(pm_dec_sigma=star.pm_dec_sigma + 128)
return star
def add_sd_metadatas(self, stars: List[StarDescription], overwrite=False):
with tqdm.tqdm(total=len(stars), desc="Adding UCAC4", unit="stars") as pbar:
for star in stars:
if not star.has_metadata("UCAC4") or overwrite:
sd = self.get_sd_from_ra_dec(
star.coords.ra.deg, star.coords.dec.deg
)
self._add_catalog_data_to_sd(star, sd, overwrite)
pbar.update(1)
def add_sd_metadata_from_id(
self, star: StarDescription, ucac4_id: str, overwrite=False
):
sd = self.get_star_description_from_id(ucac4_id)
self._add_catalog_data_to_sd(star, sd, overwrite)
@staticmethod
def _add_catalog_data_to_sd(
sd: StarDescription, ucac4_sd: StarDescription, overwrite
):
""" Add UCAC4 catalog data to a stardescription if there is none yet, or if overwrite is True """
if ucac4_sd is not None and not sd.has_metadata("UCAC4") or overwrite:
do_calibration.add_catalog_data_to_sd(
sd,
ucac4_sd.vmag,
ucac4_sd.vmag_err,
ucac4_sd.aavso_id,
"UCAC4",
ucac4_sd.coords,
extradata=ucac4_sd.get_metadata("UCAC4").extradata,
)
def main():
file_dir = '/cbs_trace1/sample_6/'
MemoryCache = LRUCache(memory_size)
SSDCache = LRUCache(cache_size)
current_time = 1538323200
for i in range(1, 31):
ssd_hit_num = 0
memory_hit_num = 0
total_read = 0
total_write = 0
memory_write_num = 0
ssd_write_num = 0
hdd_write_num = 0
print('----------------------------------')
cudate = time.strftime("%Y-%m-%d", time.localtime(current_time))
print(cudate)
current_time += 86400
print('----------------------------------')
file_name = file_dir + str(i)
f = open(file_name, "r")
print(file_name)
for line in f.readlines():
io_record = line.split(",")
#update tablet
key = io_record[4][:-2] + ',' + str(int(io_record[1]) >> 11)
if key in tablet:
a = tablet[key]
a[0] = a[0] + 1
else:
a = [1 for i in range(0, feature_num)]
tablet[key] = a
block = io_record[4][:-2] + ',' + str(int(io_record[1]) >> 6)
if int(io_record[3]) == 1:
#write
total_write += 1
ssd_write_num += 1
ssd_evict = SSDCache.set(block, 1)
if ssd_evict != None:
hdd_write_num += 1
else:
#read
total_read += 1
if SSDCache.get(block) != None:
#命中
ssd_hit_num += 1
else:
evict = SSDCache.set(block, 1)
ssd_write_num += 1
if evict != None:
hdd_write_num += 1
print("SSD footprint : %.2f %%" %
(len(SSDCache.cache) * 100 / cache_size))
print("memory_write : %.2f %%" %
(memory_write_num * 100 / total_write))
#need to write ssd log once when write to memory once
print("ssd_write : %.2f %%" %
((ssd_write_num + memory_write_num) * 100 / total_write))
print("hdd_write : %.2f %%" % (hdd_write_num * 100 / total_write))
print("Memory Hit Ratio : %.2f %%" %
(memory_hit_num * 100 / total_read))
print("SSD Hit Ratio : %.2f %%" %
((memory_hit_num + ssd_hit_num) * 100 / total_read))
#result
file = 'result/current'
f = open(file, 'a+')
#time,ssd_write,hdd_write,memory_hit,ssd_hit
f.write(
"%d\t%d\t%d\t%d\t%.2f\t%.2f\t%.2f\t%.2f\n" %
(current_time - 86400, total_write, ssd_write_num, hdd_write_num,
(ssd_write_num) * 100 / total_write, hdd_write_num * 100 /
total_write, memory_hit_num * 100 / total_read,
(memory_hit_num + ssd_hit_num) * 100 / total_read))
f.close()
class MyTestCase(unittest.TestCase):
def setUp(self):
self.cache = LRUCache(4)
def test_set_get(self):
self.cache.set('Jesse', 'James')
self.assertTrue(self.cache.get('Jesse'), 'James')
def test_delete(self):
self.cache.set('Jesse', 'James')
self.cache.get('Jesse')
self.cache.delete('Walter')
def test_out_of_memory(self):
self.cache.set('Jesse', 'James')
self.cache.set('Jim', 'Richard')
self.cache.set('Smith', 'Alex')
self.cache.set('Walter', 'White')
self.cache.set(
'Jesse',
'John') # ('Jesse', 'John') will be moved to the end of the list
self.cache.set('Williams',
'Jack') # ('Jim', 'Richard') will be deleted
self.assertEqual(self.cache.get('Jim'), None)
self.assertEqual(self.cache.get('Smith'), 'Alex')
self.cache.set('Jim', 'Richard') # ('Walter', 'White') will be deleted
self.assertEqual(self.cache.get('Walter'), None)
from LRUCache import LRUCache
if __name__ == '__main__':
cache = LRUCache(100)
cache.set('Jesse', 'Pinkman')
cache.set('Walter', 'White')
cache.set('Jesse', 'James')
cache.get('Jesse') # вернёт 'James'
cache.delete('Walter')
cache.get('Walter') # вернёт ''
