def reduce_latency(self, locations_by_uid):
for i in range(INTERDEPENDENCY_ITERATIONS):
uuid_to_interdependencies = []
for uid, location in locations_by_uid.items():
# Find a count for unique uuids a uuid is interdependent with, and how many requests for each interdependent request are made
uid_count = 0
visited = []
req_count = 0
for req in self.amap:
if uid == req['dep']:
if uid not in visited:
uid_count = uid_count + 1
visited.append(uid)
req_count = req_count + 1
uuid_to_interdependencies.append((uid, req_count))
#self.log_manager.get_interdependency_grouped_by_uuid(uuid)
for tuple in uuid_to_interdependencies:
other_item_uuid = tuple[0]
other_item_location = locations_by_uid[other_item_uuid]
request_count = tuple[1]
distance = util.get_distance(location, other_item_location)
weight = 1 / (1 + (KAPPA * distance * request_count))
location = self.interp(weight, location, other_item_location)
locations_by_uid[uid] = location
return locations_by_uid
def retrieve_data(filename):
total = []
error_count = 0
for line in open(filename, 'r'):
line = line.strip().split(',')
plong,plat,dlong,dlat=line[-4:]
try:
plong = float(plong)
plat = float(plat)
dlong = float(dlong)
dlat = float(dlat)
# part b
distance = util.get_distance(plat,plong,dlat,dlong)
ptime = float(util.change_time(line[5]))
ttime = float(line[8])
tdist = float(line[9])
total.append([ttime, tdist, ptime, distance, plong, plat, dlong, dlat])
except:
error_count += 1
data = np.asarray(total)
print "number of distances","maximum distance","minimum distance"
print len(data[:,3]),max(data[:,3]),min(data[:,3]) # distance is measured in miles
return data
def evaluate(self, read_logs=None, moving_logs=None):
# collect server logs
if read_logs is None:
read_logs = self.aggregator.get_read_log_entries(
self.start_time, self.end_time)
if moving_logs is None:
moving_logs = self.aggregator.get_moving_log_entries(
self.start_time, self.end_time)
# calculate the average latency
latency_sum = 0
request_count = 0
ip_cache = ip_location_cache()
for log in read_logs:
timestamp, uuid, source, source_uuid, dest, req_type, status, response_size = log
client_loc = ip_cache.get_lat_lon_from_ip(source)
server_loc = ip_cache.get_lat_lon_from_ip(dest)
distance = util.get_distance(client_loc, server_loc)
unit = 1000.0
latency = distance / unit
request_importance = 1
latency_sum += latency * request_importance
request_count += request_importance
average_latency = latency_sum / request_count
inter_datacenter_traffic = 0
for log in moving_logs:
timestamp, uuid, source, source_uuid, dest, req_type, status, response_size = log
# treat all files as uniform size
inter_datacenter_traffic += 1
# display latency, cost, etc
return average_latency, inter_datacenter_traffic
def get_dict(self, sort_type, lat=None, long=None):
dict = {}
dict['name'] = self.name
dict['location'] = self.location
dict['building_name'] = self.building_name
dict['atResidence'] = self.atResidence
dict['latitude'] = self.latitude
dict['longitude'] = self.longitude
dict['error_msg'] = self.error_msg
dict['status'] = self.status
if sort_type == 'name':
dict['section_header'] = dict['name'][0]
dict['distance'] = 0.0
elif sort_type == 'building':
dict['section_header'] = dict['building_name']
dict['distance'] = 0.0
elif sort_type == 'distance':
if lat == None or long == None:
dict['section_header'] = ""
else:
dist = util.get_distance(lat, long, self.latitude / 1000000.0, self.longitude / 1000000.0)
dict['distance'] = dist
if dist < 0.1:
dict['section_header'] = "< 0.1 miles"
elif dist >= 0.1 and dist < 0.3:
dict['section_header'] = "0.1 - 0.3 miles"
elif dist >= 0.3 and dist < 0.5:
dict['section_header'] = "0.3 - 0.5 miles"
elif dist >=0.5 and dist < 1.0:
dict['section_header'] = "0.5 - 1.0 miles"
else:
dict['section_header'] = "> 1.0 miles"
else:
dict['section_header'] = ""
return dict
def filter_places(api, places, start, min_rating):
highest_rated = {}
closest = {}
closest_dist = 5000
result_term = 'results' if api == 'google' else 'businesses'
review_count_term = 'user_ratings_total' if api == 'google' else 'review_count'
if not places.get(result_term, False):
print('No places of place type for {} - places = {}'.format(
start, places))
return None
for idx, place in enumerate(places[result_term]):
#print ('place {}'.format(idx))
if api == 'google':
if place['business_status'] == 'CLOSED_PERMANENTLY':
#print('It"s closed bitches - {}'.format(place['business_status']))
continue
else:
if place['is_closed'] == 'true':
#print('It"s closed bitches - {}'.format(place['is_closed']))
continue
if place['rating'] < min_rating and place[review_count_term] >= 10:
#print('It"s shit - Rating {} from {} reviews'.format(place['rating'],place[review_count_term]))
continue
if place['rating'] > highest_rated.get('rating', 0):
highest_rated = place
if api == 'google':
place_geo = (place['geometry']['location']['lat'],
place['geometry']['location']['lng'])
else:
place_geo = (place['coordinates']['latitude'],
place['coordinates']['longitude'])
place_dist = get_distance(place_geo, start)
if place_dist < closest_dist:
closest = place
closest_dist = place_dist
#print('Highest Rated ({}):'.format(highest_rated.get('rating',0)))
#print(json.dumps(highest_rated, indent=2))
#print('Closest ({}mi):'.format(closest_dist))
#print(json.dumps(closest, indent=2))
return {
'highest_rated': {
'place': highest_rated,
'value': highest_rated.get('rating', 0)
},
'closest': {
'place': closest,
'value': closest_dist
}
}
def reduce_latency(self, locations_by_uuid):
for i in range(INTERDEPENDENCY_ITERATIONS):
for uuid, location in locations_by_uuid.iteritems():
uuid_to_interdependencies = self.log_manager.get_interdependency_grouped_by_uuid(
uuid)
for tuple in uuid_to_interdependencies:
other_item_uuid = tuple[0]
other_item_location = locations_by_uuid[other_item_uuid]
request_count = tuple[1]
distance = util.get_distance(location, other_item_location)
weight = 1 / (1 + (KAPPA * distance * request_count))
location = self.interp(weight, location,
other_item_location)
locations_by_uuid[uuid] = location
return locations_by_uuid
def get_reward(self, data):
global name
global last_data
score = data['tanks'][config.TANK_ID[name]]['score']
last_score = last_data['tanks'][config.TANK_ID[name]]['score'] if last_data else score
last_pos = (last_data['tanks'][config.TANK_ID[name]]['position'][0],
last_data['tanks'][config.TANK_ID[name]]['position'][1],
last_data['tanks'][config.TANK_ID[name]]['direction']) if last_data else (0, 0, 0)
distance = util.get_distance(self.me, last_pos)
reward = score-last_score
if reward == 0:
if distance < 0.15:
reward = -5
elif reward < 0:
reward = -10
print("reward is {}.".format(reward))
return reward
def compute_min_dis(points_1, points_2):
min_dis = 100
for i in itertools.product(points_1[0], points_2[0]):
distance = calculate_distance(i[0], i[1])
if distance < min_dis:
min_dis = distance
central_dis = calculate_distance(np.mean(points_1[0], axis=0),
np.mean(points_2[0], axis=0))
if central_dis < min_dis:
min_dis = central_dis
# max_xyz_1 = np.max(np.array(points_1), axis=0)
# min_xyz_1 = np.min(np.array(points_1), axis=0)
# max_xyz_2 = np.max(np.array(points_2), axis=0)
# min_xyz_2 = np.min(np.array(points_2), axis=0)
# four_1 = [(max_xyz_1[0], max_xyz_1[1]), (min_xyz_1[0], min_xyz_1[1]),
# (min_xyz_1[0], max_xyz_1[1]), (max_xyz_1[0], min_xyz_1[1])]
# four_2 = [(max_xyz_2[0], max_xyz_2[1]), (min_xyz_2[0], min_xyz_2[1]),
# (min_xyz_2[0], max_xyz_2[1]), (max_xyz_2[0], min_xyz_2[1])]
# dis = util.get_distance_simple(four_1, four_2)
dis = util.get_distance(points_1[1], points_2[1])
if dis < min_dis:
min_dis = dis
return min_dis
def get_observation(self, data):
# observation = []
tank_observation = []
bullet_observation = []
tanks = data['tanks']
bullets = data['bullets']
global name
# --------------------------me---------------------------------
my_tank = tanks[self.my_tank_name]
self.me = [my_tank['position'][0], my_tank['position'][1], my_tank['direction'],
my_tank['score'], my_tank['fireCd'], my_tank['shieldCd'],
my_tank['rebornCd'] if my_tank['rebornCd'] else 0]
# ------------------------enemy--------------------------------
self.enemy_list = []
for (tank_name, value) in tanks.items():
if tank_name == self.my_tank_name:
continue
# -----------tank feature------------
enemy = [value['position'][0], value['position'][1], value['direction'],
value['score'], value['fireCd'], value['shieldCd'], value['rebornCd'] if value['rebornCd'] else 0]
self.enemy_list.append(enemy)
# sorted by score from minimum to maximum
self.enemy_list = sorted(self.enemy_list, key=lambda x:x[3], reverse=False)
# while len(self.enemy_list) < MAX_TANK:
# self.enemy_list.append([0]*TANK_FEATURES)
for enemy in self.enemy_list[:MAX_TANK]:
tank_observation += [e for e in enemy[:TANK_FEATURES]]
tank_observation = np.pad(tank_observation,
(0, MAX_TANK*TANK_FEATURES-len(tank_observation)), 'constant')
print("The length of tank_observation is {}".format(len(tank_observation)))
# ------------------------bullet-------------------------------
self.bullet_list = []
for bullet in bullets:
# ------------bullet feature-------------
distance = util.get_distance(self.me, [bullet['position'][0], bullet['position'][1]])
self.bullet_list.append([
bullet['position'][0], bullet['position'][1], bullet['direction'], distance])
# sorted by distance from maximum to minimum
self.bullet_list = sorted(self.bullet_list, key=lambda x:x[3], reverse=True)
# while len(self.bullet_list) < MAX_BULLET:
# self.bullet_list.append([0]*BULLET_FEATURES)
for bullet in self.bullet_list[:MAX_BULLET]:
bullet_observation += [b for b in bullet[:BULLET_FEATURES]]
bullet_observation = np.pad(bullet_observation,
(0, MAX_BULLET*BULLET_FEATURES-len(bullet_observation)), 'constant')
print("The length of bullet_observation is {}".format(len(bullet_observation)))
return {
"tank": np.reshape(np.array(tank_observation), (-1, TANK_FEATURES)),
"bullet": np.reshape(np.array(bullet_observation), (-1, BULLET_FEATURES))
}
