Add GreedySearch algorithm (9cd3bba5) · Commits · LARN / PRRT

prrt/hec_search.py

+92 −20

Original line number	Diff line number	Diff line
		@@ -19,6 +19,7 @@ class HECFullSearch(AbstractSearch):
		self.prrtChannelParameters = prrtChannelParameters
		self.prrtSystemParameters = prrtSystemParameters
		self.p_t = self.prrtApplicationParameters.max_residual_loss_rate
		self.is_order_ascending = False
		pass

		def search(self):
		@@ -45,7 +46,7 @@ class HECFullSearch(AbstractSearch):
		k_max = min(self.get_k(n_c, req_delay), self.get_k_lim(1, self.n_max))
		for k in range(1, k_max + 1):
		n = self.estimate_n_for_k(k)
		repair_schedules = ric.gen_repair_schedule(n - k, n_c, 1, self.n_p_max)
		repair_schedules = ric.gen_repair_schedule(n - k, n_c, 1, self.n_p_max, self.is_order_ascending)
		for repair_schedule in repair_schedules:
		coding_conf = prrt.PrrtCodingConfiguration(n, k, repair_schedule)
		ri = coding_conf.get_redundant_information(self.prrtChannelParameters)
		@@ -101,22 +102,93 @@ class HECFullSearch(AbstractSearch):
		return residual_packet_erasure_rate


		# Restricted Integer combinations
		"""
		def partitionfunc(n, k, smallest=1):
		'''n is the integer to partition, k is the length of partitions, smallest is the min partition element size'''
		if k < 1:
		raise StopIteration
		if k == 1:
		if n >= smallest:
		yield (n,)
		raise StopIteration
		for i in range(smallest, n + 1):
		for result in partitionfunc(n - i, k - 1, i):
		yield (i,) + result


		generator = partitionfunc(3, 1, )
		for i in generator:
		print(i)
		"""
		No newline at end of file
		class HECGreedySearch(AbstractSearch):
		def __init__(self, n_p_max, prrtApplicationParameters, prrtChannelParameters, prrtSystemParameters):
		self.n_max = 255
		self.step_size = 2 # Step size in the estimation of the optimum code word length
		self.n_p_max = n_p_max
		self.prrtApplicationParameters = prrtApplicationParameters
		self.prrtChannelParameters = prrtChannelParameters
		self.prrtSystemParameters = prrtSystemParameters
		self.p_t = self.prrtApplicationParameters.max_residual_loss_rate
		self.is_order_ascending = True
		pass

		def search(self):
		ri_opt = math.inf
		k_opt = 0
		n_opt = 0
		n_p_opt = []
		# Eq.5.9, page 125
		fec_delay_min = self.prrtSystemParameters.source_packet_interval + \
		self.n_p_max * self.prrtSystemParameters.redundancy_packet_transmission_delay + \
		(self.prrtChannelParameters.rtt_prop_fwd + self.prrtSystemParameters.processing_delay) / 2 + \
		self.prrtSystemParameters.packet_loss_detection_delay
		# Eq.5.9 page 125 assumung D_sup = 0
		req_delay = self.prrtChannelParameters.rtt_prop_fwd + \
		self.n_p_max * self.prrtSystemParameters.redundancy_packet_transmission_delay + \
		self.prrtSystemParameters.processing_delay
		# Eq.5.10, page 125
		n_c_max = math.ceil((self.prrtApplicationParameters.max_latency - fec_delay_min) / req_delay)
		# self.k_lim = somewhat(prrtApplicationParameters.loss_tolerance, self.n_max)

		# n_c = 0 is the proactive packet
		for n_c in range(n_c_max):
		# Eq.5.11, k(Nc, D_T), page 125
		k_max = min(self.get_k(n_c, req_delay), self.get_k_lim(1, self.n_max))
		for k in [1, k_max]:
		n = self.estimate_n_for_k(k)
		repair_schedules = ric.gen_repair_schedule(n - k, n_c, 1, self.n_p_max, self.is_order_ascending)
		for repair_schedule in repair_schedules:
		coding_conf = prrt.PrrtCodingConfiguration(n, k, repair_schedule)
		ri = coding_conf.get_redundant_information(self.prrtChannelParameters)
		if ri < ri_opt:
		k_opt = k
		n_opt = n
		n_p_opt = repair_schedule
		return prrt.PrrtCodingConfiguration(n_opt, k_opt, n_p_opt)

		def get_k(self, n_c, req_delay):
		return math.ceil((self.prrtApplicationParameters.max_latency -
		self.n_p_max * self.prrtSystemParameters.redundancy_packet_transmission_delay -
		(self.prrtChannelParameters.rtt_prop_fwd + self.prrtSystemParameters.processing_delay) / 2 -
		self.prrtSystemParameters.packet_loss_detection_delay -
		n_c * req_delay) / self.prrtSystemParameters.source_packet_interval)

		def get_k_lim(self, start, end):
		mid_point = math.ceil((end - start) / 2)
		p_r = self.get_max_coding_block_length(mid_point)
		if p_r == self.p_t:
		return mid_point
		elif p_r > self.p_t:
		self.get_k_lim(start, mid_point - 1)
		else:
		self.get_k_lim(mid_point + 1, end)

		# Pr(k, n_max)
		def get_max_coding_block_length(self, k):
		total_packet_erasure = 0
		for i in range(1, k):
		for j in range(max(self.n_max - k + 1, i), self.n_max - k + i):
		packet_erasure_at_i = i * self.hypergeometric_distribution(self.n_max, k, i, j) * self.get_error_prob(
		j, self.n_max, self.prrtChannelParameters.loss_rate_fwd)
		total_packet_erasure += packet_erasure_at_i
		return (1 / k) * total_packet_erasure

		def estimate_n_for_k(self, k):
		n = k + 1
		while self.residual_packet_erasure_rate(k, n, self.prrtApplicationParameters, self.prrtChannelParameters) > self.prrtApplicationParameters.max_residual_loss_rate\
		and n <= self.n_max - self.step_size:

		print("")

		return 0

		def residual_packet_erasure_rate(self, k, n, prrtApplicationParameters, prrtChannelParameters):
		total_packet_erasure = 0
		for i in range(1, k):
		for j in range(max(n - k + 1, i), n - k + i):
		packet_erasure_at_i = i * self.hypergeometric_distribution(n, k, i, j) * self.get_error_prob(j, n, prrtChannelParameters.loss_rate_fwd)
		total_packet_erasure += packet_erasure_at_i
		residual_packet_erasure_rate = (1 / k) * total_packet_erasure # Pr(k, n)
		return residual_packet_erasure_rate
		No newline at end of file

prrt/ric.pyx

+11 −8

Original line number	Diff line number	Diff line
		@@ -19,15 +19,18 @@ def generate_restricted_integer_compositions(redundancy, positions, min, max):
		if (i <= c_max):
		yield (i,) + result

		def gen_repair_schedule(redundancy, positions, min, max):
		rawList = []
		permuted = set()
		# is_order_ascending = False for full search and True for greedy search
		def gen_repair_schedule(redundancy, positions, min, max, is_order_ascending):
		arbitrary_schedules = []
		ordered_schedules = set()

		f = generate_restricted_integer_compositions(redundancy, positions, min, max)
		for i in f:
		rawList.add(i)
		arbitrary_schedules.add(i)

		for i in rawList:
		permuted.append(itertools.permutations(i))

		return permuted
		No newline at end of file
		if not is_order_ascending:
		for i in arbitrary_schedules:
		ordered_schedules.append(itertools.permutations(i))
		return list(ordered_schedules)
		else:
		return arbitrary_schedules
		No newline at end of file