├── .gitignore
├── Propuesta Black Hole Algorithm
    └── A_Dynamic_Programming_Offloading_Algorithm_for_Mobile_Cloud_Computing.pdf
├── README.md
├── img
    ├── img1.png
    └── img2.png
└── src
    ├── blackHole.py
    └── dinamicProgramming.py


/.gitignore:
--------------------------------------------------------------------------------
  1 | # Byte-compiled / optimized / DLL files
  2 | __pycache__/
  3 | *.py[cod]
  4 | *$py.class
  5 | 
  6 | # C extensions
  7 | *.so
  8 | 
  9 | # Distribution / packaging
 10 | .Python
 11 | build/
 12 | develop-eggs/
 13 | dist/
 14 | downloads/
 15 | eggs/
 16 | .eggs/
 17 | lib/
 18 | lib64/
 19 | parts/
 20 | sdist/
 21 | var/
 22 | wheels/
 23 | pip-wheel-metadata/
 24 | share/python-wheels/
 25 | *.egg-info/
 26 | .installed.cfg
 27 | *.egg
 28 | MANIFEST
 29 | 
 30 | # PyInstaller
 31 | #  Usually these files are written by a python script from a template
 32 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 33 | *.manifest
 34 | *.spec
 35 | 
 36 | # Installer logs
 37 | pip-log.txt
 38 | pip-delete-this-directory.txt
 39 | 
 40 | # Unit test / coverage reports
 41 | htmlcov/
 42 | .tox/
 43 | .nox/
 44 | .coverage
 45 | .coverage.*
 46 | .cache
 47 | nosetests.xml
 48 | coverage.xml
 49 | *.cover
 50 | .hypothesis/
 51 | .pytest_cache/
 52 | 
 53 | # Translations
 54 | *.mo
 55 | *.pot
 56 | 
 57 | # Django stuff:
 58 | *.log
 59 | local_settings.py
 60 | db.sqlite3
 61 | db.sqlite3-journal
 62 | 
 63 | # Flask stuff:
 64 | instance/
 65 | .webassets-cache
 66 | 
 67 | # Scrapy stuff:
 68 | .scrapy
 69 | 
 70 | # Sphinx documentation
 71 | docs/_build/
 72 | 
 73 | # PyBuilder
 74 | target/
 75 | 
 76 | # Jupyter Notebook
 77 | .ipynb_checkpoints
 78 | 
 79 | # IPython
 80 | profile_default/
 81 | ipython_config.py
 82 | 
 83 | # pyenv
 84 | .python-version
 85 | 
 86 | # pipenv
 87 | #   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
 88 | #   However, in case of collaboration, if having platform-specific dependencies or dependencies
 89 | #   having no cross-platform support, pipenv may install dependencies that don't work, or not
 90 | #   install all needed dependencies.
 91 | #Pipfile.lock
 92 | 
 93 | # celery beat schedule file
 94 | celerybeat-schedule
 95 | 
 96 | # SageMath parsed files
 97 | *.sage.py
 98 | 
 99 | # Environments
100 | .env
101 | .venv
102 | env/
103 | venv/
104 | ENV/
105 | env.bak/
106 | venv.bak/
107 | 
108 | # Spyder project settings
109 | .spyderproject
110 | .spyproject
111 | 
112 | # Rope project settings
113 | .ropeproject
114 | 
115 | # mkdocs documentation
116 | /site
117 | 
118 | # mypy
119 | .mypy_cache/
120 | .dmypy.json
121 | dmypy.json
122 | 
123 | # Pyre type checker
124 | .pyre/
125 | 


--------------------------------------------------------------------------------
/Propuesta Black Hole Algorithm/A_Dynamic_Programming_Offloading_Algorithm_for_Mobile_Cloud_Computing.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lehi10/Black-Hole-Algorithm-in-Computational-Offloading-for-Mobile-Cloud-Computing/f9f250f48e993597668d90e75e1dd446493320ec/Propuesta Black Hole Algorithm/A_Dynamic_Programming_Offloading_Algorithm_for_Mobile_Cloud_Computing.pdf


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Black Hole Algorithm in Computational Offloading for Mobile Cloud Computing
 2 | Project of Cloud Computer (Short Paper)
 3 | 
 4 | ### Requirements
 5 | ```
 6 | Python 2.7
 7 | Numpy
 8 | ```
 9 | ### Compile
10 | ```
11 | python blackHole.py
12 | python dinamicProgramming.py
13 | ```
14 | 
15 | ### Paper Base : A Dynamic Programming Offloading Algorithm for Mobile Cloud Computing 
16 | _"Computational  offloading  is  an  effective  method  to  address   the   limited   battery   power   of   a   mobile   device,   by   executing some components of a mobile application in the cloud. In  this  paper,  a  novel  offloading  algorithm  called  ‘Dynamic  Programming  with  Hamming  Distance  Termination’ ..."_
17 | 
18 | https://ieeexplore.ieee.org/document/7726790
19 | 
20 | 
21 | ### Results of implementation and comparison with DPH algorithm
22 | 
23 | Cost of Energy of DPH and BlackHole
24 | <img src="https://github.com/lehi10/Black-Hole-Algorithm-in-Computational-Offloading-for-Mobile-Cloud-Computing/blob/master/img/img1.png"  width="400"  />
25 | 
26 | Time of execution of DPH and BlackHole
27 | <img src="https://github.com/lehi10/Black-Hole-Algorithm-in-Computational-Offloading-for-Mobile-Cloud-Computing/blob/master/img/img2.png"  width="400"  />
28 | 


--------------------------------------------------------------------------------
/img/img1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lehi10/Black-Hole-Algorithm-in-Computational-Offloading-for-Mobile-Cloud-Computing/f9f250f48e993597668d90e75e1dd446493320ec/img/img1.png


--------------------------------------------------------------------------------
/img/img2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lehi10/Black-Hole-Algorithm-in-Computational-Offloading-for-Mobile-Cloud-Computing/f9f250f48e993597668d90e75e1dd446493320ec/img/img2.png


--------------------------------------------------------------------------------
/src/blackHole.py:
--------------------------------------------------------------------------------
  1 | import numpy as np
  2 | import random
  3 | import math
  4 | 
  5 | 
  6 | import random as rand
  7 | from numpy.random import randint
  8 | 
  9 | # Tareas
 10 | tasks = [5930,3900,1700,6880,6800,2400,5960
 11 |         ,5400,8700,900,800,900,5900,7700,6200]
 12 | 
 13 | 
 14 | N = len(tasks) # 15 TAREAS 
 15 | 
 16 | 
 17 | def allOf(A,num):
 18 |     size = len(A)
 19 |     for i in range(size):
 20 |         if A[i] != num:
 21 |             return False
 22 |     return True
 23 | 
 24 | 
 25 | 
 26 | def Cal_E_T7(T_rate, tasks, N):
 27 |     Beta = 5e-7
 28 |     
 29 |     Cff =730e6 # Energia por ciclo
 30 |     Dff =860e3 # Byte/energia
 31 |     
 32 |     TC=np.zeros(N)
 33 |     EC=np.zeros(N)
 34 |     
 35 |     EL=np.zeros(N)
 36 |     Et=np.zeros(N)
 37 |     Er=np.zeros(N)
 38 |     
 39 |     TL=np.zeros(N)
 40 |     Tr=np.zeros(N)
 41 |     Tt=np.zeros(N)
 42 |     
 43 |     F_local=500e6
 44 |     F_cloud=10e9
 45 |     
 46 |     D_out=(3*np.random.rand(N))
 47 |     D_in= randint(10,31,N)
 48 |     
 49 |     for ii in range(N):
 50 |         D_in[ii] = 1/D_in[ii]
 51 |         D_out[ii] = 1/D_out[ii]
 52 |         
 53 |     Cci=D_in
 54 |     for i in range(N):
 55 |         EL[i] = tasks[i]/(8*Cff)
 56 |         TL[i] = tasks[i]/(8*F_local)
 57 |         
 58 |         Er[i] = 1/(8*Dff)
 59 |         Tr[i] = D_out[i]/T_rate
 60 |         Tc_temp = D_in[i] * tasks[i]/(8*F_cloud)
 61 |         
 62 |         Et[i] = 1/(8*Dff)
 63 |         Tt[i] = D_in[i]/T_rate
 64 |         
 65 |         TC[i] = Tr[i] + Tt[i] + Tc_temp
 66 |         EC[i] = Er[i] + Et[i] + Beta * Cci[i]
 67 |         
 68 |     return EL, EC, TL, TC , Cci
 69 |     
 70 | 
 71 | 
 72 | 
 73 | 
 74 | populationSize =3
 75 | 
 76 | dimention = len(tasks)
 77 | numIterations = 1000
 78 | 
 79 | lowerLimit = 0
 80 | upperLimit = 2
 81 | T_constraint=700
 82 | 
 83 | population=[]
 84 | 
 85 | blackHole={"star":[],"fitness":99999999}
 86 | 
 87 | 
 88 | iter1 = 50
 89 | E_min=1
 90 | T_constraint = 700
 91 | T_rate = 3e6
 92 | 
 93 | EC = []
 94 | EL = []
 95 | TL = []
 96 | TC = []
 97 | 
 98 | EL, EC, TL, TC , Cci = Cal_E_T7(T_rate, tasks, N)
 99 | 
100 | E=np.zeros(N);
101 | T=np.zeros(N);
102 | 
103 | def printPopulation():
104 | 	for i in population:
105 | 		print i
106 | 
107 | def initPopulation():
108 | 	for i in range(populationSize):
109 | 		star=randint(lowerLimit,upperLimit,dimention)
110 | 		individual = {"star":star,"fitness":0}
111 | 		population.append(individual)
112 | 			
113 | 
114 | def objetiveFunction(x):
115 | 	size_x = len(x)
116 | 	for i in range(size_x):
117 | 	    E[i]= x[i]*EL[i]+(1-x[i])*EC[i]
118 | 	    T[i]= x[i]*TL[i]+(1-x[i])*TC[i]
119 | 	    if(sum(T)>T_constraint):
120 | 	        return 9999999
121 | 	return sum(E)
122 | 
123 | def evaluatePopulation():
124 | 	for individual in population:
125 | 		individual["fitness"]=objetiveFunction(individual["star"])
126 | 
127 | def selectBlackHole():
128 | 	global blackHole
129 | 	population.sort(key=lambda x: x["fitness"])
130 | 	if population[0]["fitness"]<blackHole["fitness"]:	
131 | 		blackHole=population.pop(0)
132 | 		
133 | 		star =randint(lowerLimit,upperLimit,dimention)
134 | 		
135 | 		individual = {"star":star,"fitness":0}
136 | 		population.append(individual)
137 | 		
138 | 		
139 | def changeLocationsStars():
140 | 	for individual in population:
141 | 		rand=np.random.rand(dimention)
142 | 		#individual["star"]=individual["star"]+(rand*(blackHole["star"]-individual["star"]))
143 | 		individual["star"]= np.logical_or(np.logical_not(individual["star"]),blackHole["star"]) #np.logical_or(np.logical_xor(blackHole["star"],individual["star"]),individual["star"])*1
144 | 
145 | 		    
146 | 	evaluatePopulation()
147 | 
148 | def findStartWithLowerCost():
149 | 	global blackHole
150 | 	population.sort(key=lambda x: x["fitness"])
151 | 
152 | 	if population[0]["fitness"] < blackHole["fitness"]:
153 | 		temp = population[0]
154 | 		population[0]=blackHole
155 | 		blackHole=temp
156 | 
157 | 
158 | 
159 | def crossingEventHorizon():
160 | 	sumFi=sum([ i['fitness'] for i in population])	
161 | 	R=blackHole["fitness"]/(sumFi)
162 | 
163 | 	for inv in population:
164 | 		euclideanDistance=np.linalg.norm(blackHole["star"]-inv["star"]) 
165 | 		if euclideanDistance <  R:
166 | 			star =np.zeros(dimention)
167 | 			for j in range(dimention):
168 | 				star[j]=randint(lowerLimit,upperLimit)
169 | 			inv["star"]=star
170 | 			
171 | 
172 | 
173 | def blackHoleAlgorithm():
174 | 	print "Inicializando poblacion"
175 | 	initPopulation()
176 | 	printPopulation()
177 | 	evaluatePopulation()
178 | 	for i in range(numIterations):
179 | 		evaluatePopulation()
180 | 
181 | 		selectBlackHole()
182 | 		changeLocationsStars()
183 | 		findStartWithLowerCost()
184 | 		crossingEventHorizon()
185 | 	print blackHole
186 | 	print "Energia minima : ", blackHole['fitness']
187 | 
188 | import time
189 | start_time = time.time()
190 | 				
191 | blackHoleAlgorithm()
192 | 
193 | print("--- %s seconds ---" % (time.time() - start_time))
194 | 
195 | 
196 | 


--------------------------------------------------------------------------------
/src/dinamicProgramming.py:
--------------------------------------------------------------------------------
  1 | import numpy as np
  2 | import random as rand
  3 | from numpy.random import randint
  4 | 
  5 | def allOf(A,num):
  6 |     size = len(A)
  7 |     for i in range(size):
  8 |         if A[i] != num:
  9 |             return False
 10 |     return True
 11 | 
 12 | 
 13 | def Cal_E_T7(T_rate, tasks, N):
 14 |     Beta = 5e-7 # B es el 
 15 |     
 16 |     Cff =730e6 # Energia por ciclo
 17 |     Dff =860e3 # Byte/energia
 18 |     
 19 |     TC=np.zeros(N)
 20 |     EC=np.zeros(N)
 21 |     
 22 |     EL=np.zeros(N)
 23 |     Et=np.zeros(N)
 24 |     Er=np.zeros(N)
 25 |     
 26 |     TL=np.zeros(N)
 27 |     Tr=np.zeros(N)
 28 |     Tt=np.zeros(N)
 29 |     
 30 |     F_local=500e6   # CPU rate localy
 31 |     F_cloud=10e9    # CPU rateof Cloud
 32 |     
 33 |     D_out=(3*np.random.rand(N)) # Ouput data size  1 a 3 MB
 34 |     D_in= randint(10,31,N)      # Input data size  10 a 30 MB
 35 |     
 36 |     for ii in range(N):
 37 |         D_in[ii] = 1/D_in[ii]
 38 |         D_out[ii] = 1/D_out[ii]
 39 |         
 40 |     Cci=D_in
 41 |     for i in range(N):
 42 |         
 43 |         EL[i] = tasks[i]/(8*Cff) # Consumo de Energia local
 44 |         TL[i] = tasks[i]/(8*F_local) # Tiempo por tareas local
 45 |         
 46 |         Er[i] = 1/(8*Dff)   # Consumo de energia remoto
 47 |         Tr[i] = D_out[i]/T_rate # Tiempo de ejecucion remoto
 48 |         Tc_temp = D_in[i] * tasks[i]/(8*F_cloud) 
 49 |         
 50 |         Et[i] = 1/(8*Dff) # Consumo de energia Transmision
 51 |         Tt[i] = D_in[i]/T_rate # Tiempo de transmision
 52 |         
 53 |         TC[i] = Tr[i] + Tt[i] + Tc_temp
 54 |         
 55 |         EC[i] = Er[i] + Et[i] + Beta * Cci[i]  # 
 56 |         
 57 |     return EL, EC, TL, TC , Cci
 58 |     
 59 | 
 60 | def GA(tasks,N):
 61 |     mutation_probability = 0.5
 62 |     number_of_generations = 100000
 63 |     iter1 = 50
 64 |     E_min = 1
 65 |     T_constraint=700 # 
 66 |     T_rate=3e6; 
 67 |     EC=[]
 68 |     EL=[]
 69 |     TL=[]
 70 |     TC=[]
 71 |     
 72 |     EL, EC, TL, TC , Cci = Cal_E_T7(T_rate, tasks, N)
 73 | 
 74 |     
 75 |     x = randint(0,2,N)
 76 |     
 77 |     if allOf(x,1) or allOf(x,0):
 78 |         x = randint(0,2,N)
 79 |     
 80 |     E=np.zeros(N)
 81 |     T=np.zeros(N)
 82 |     
 83 |     for k in range(N):
 84 |         E[k]=x[k]*EL[k]+(1-x[k])*EC[k]
 85 |         T[k]=x[k]*TL[k]+(1-x[k])*TC[k]
 86 | 
 87 | 
 88 |     E_min=1e20
 89 |     
 90 |     
 91 |     T_min=1e20
 92 |     
 93 |     
 94 |     Xmin = []
 95 |     for j in range(number_of_generations):
 96 |         x = randint(0,2,N)
 97 |         if allOf(x,1) or allOf(x,0):
 98 |             x = randint(0,2,N)
 99 |         cut_point=randint(1,N)
100 |         
101 |         x = x[0:cut_point]
102 |         x_2=randint(0,2,N-cut_point)
103 |         x = np.append(x,x_2)
104 |         
105 |         rand_mut = np.random.rand()
106 |         
107 |         if rand_mut < mutation_probability:
108 |             gene_position = randint(0,N,2)
109 |             gene_position = np.sort(gene_position)
110 |             
111 |             a = x[gene_position[0]:gene_position[1]]
112 |             
113 |             fl = -np.sort(-a)
114 |             
115 |         for k in range(N):
116 |             E[k] = x[k]*EL[k]+(1-x[k])*EC[k]
117 |             T[k] = x[k]*TL[k]+(1-x[k])*TC[k]
118 |         if sum(E) <= E_min and sum(T) < T_constraint:
119 |             E_min=sum(E)
120 |             E_min=sum(T)
121 |             Xmin=x
122 |     Decision_Matrix=Xmin
123 |     return Decision_Matrix,E_min, T_min
124 |     
125 | 
126 | 
127 | 
128 | # Programacion dinamica
129 | def dynamicProg(tasks,N):
130 |     iter1 = 50  # Numero de iteraciones
131 |     E_min=1     # E_minimo
132 |     T_constraint = 700  
133 |     T_rate = 3e6  
134 |     
135 |     EC = []
136 |     EL = []
137 |     TL = []
138 |     TC = []
139 | 
140 |     EL, EC, TL, TC , Cci = Cal_E_T7(T_rate, tasks, N)
141 |     
142 |     print EL
143 |     print EC
144 |     print TL
145 |     print TC
146 | 
147 |     
148 |     table1 = 2*np.ones((N,N))
149 | 
150 |     E = np.zeros((N,N))
151 |     E_total = np.zeros(iter1)
152 |     
153 |     T = np.zeros((N,N))
154 |     T_total = np.zeros(iter1)
155 | 
156 |     visited = np.zeros((N,N))
157 |     table2={}
158 | 
159 |     Decision_Matrix = np.zeros(N)
160 |     E1 = {}
161 | 
162 |     for iter in range(iter1):
163 |         M = randint(0,2,N)
164 |         if allOf(M,1) or allOf(M,0):
165 |             M = randint(0,2,N)
166 |         
167 |         i=1
168 |         j=1
169 |         
170 |         table1 = 2*np.ones((N,N))
171 |         
172 |         for k in range(N):
173 |             if M[k] == 0:
174 |                 i+=1
175 |                 table1[i,j]=M[k]
176 |             else:
177 |                 j+=1
178 |                 table1[i,j]=M[k]
179 |             
180 |             #M[k]=1
181 |             if visited[i,j]==0:
182 |                 E[i,j] = M[k]*EL[k]+(1-M[k])*EC[k] 
183 |                 T[i,j] = M[k]*TL[k]+(1-M[k])*TC[k] 
184 |                 
185 |                 visited[i,j] = 1
186 |                 table2[i,j] = M[k]
187 |                 E1[k]=E[i,j]
188 | 
189 |                 if E1[k] < 2e-7:
190 |                     Decision_Matrix[k]=M[k]
191 |             else:
192 |                 e= M[k]*EL[k]+(1-M[k])*EC[k] 
193 |                 t= M[k]*TL[k]+(1-M[k])*TC[k]
194 |                  
195 |                 
196 |                 if E[i,j] > e:
197 |                     E1[k]=e
198 |                     Decision_Matrix[k]=M[k]
199 |                     table2[i,j]=M[k]
200 |                     E[i,j]=e
201 |                     T[i,j]=t
202 |                     
203 |                 elif E[i,j] == e:
204 |                     if e < 2e-7:
205 |                         Decision_Matrix[k]=M[k]
206 |         E_total[iter]= np.sum(E)
207 |         T_total[iter]= np.sum(T)
208 |         
209 |         if iter == iter1/3 and len(Decision_Matrix)==N:
210 |             T_rate=5e6
211 |             EL,EC,TL,TC,Cci = Cal_E_T7(T_rate,tasks,N)
212 |         elif iter== 2*iter1/3 and len(Decision_Matrix)==N :
213 |             T_rate=8e6
214 |             EL,EC,TL,TC,Cci = Cal_E_T7(T_rate,tasks,N)
215 | 
216 |         if E_total[iter]<=E_min and T_total[iter] < T_constraint and  len(E1)==N:
217 |             E_min=E_total[iter]
218 |             T_min=T_total[iter]
219 |             it=iter
220 |     return Decision_Matrix, E_min, T_min
221 |         
222 |         
223 |         
224 | 
225 | 
226 | 
227 | tasks = [5930,3900,1700,6880,6800,2400,5960
228 |         ,5400,8700,900,800,900,5900,7700,6200]
229 | 
230 | import time
231 | start_time = time.time()
232 | 
233 | N = len(tasks)
234 | 
235 | Decision_Matrix_Dynamic ,E_min, T_min = dynamicProg(tasks,N)
236 | #Decision_Matrix_Dynamic,E_min, T_min = GA(tasks,N)
237 | 
238 | print Decision_Matrix_Dynamic 
239 | print "Energia minima : " ,E_min
240 | print "Tiempo mminimo : ", T_min
241 | 
242 | print("--- %s seconds ---" % (time.time() - start_time))
243 | 


--------------------------------------------------------------------------------