├── .gitignore
├── .project
├── .pydevproject
├── README
├── README.md
├── assembly_compilation_ARM
    └── main_original.s
├── assembly_compilation_x86_gcc
    └── main_original.s
├── configurationFiles
    ├── configuration-template-explanation.xml
    ├── configuration_ARM_IPC.xml
    ├── configuration_likwidPowerMeter.xml
    ├── configuration_x86_IPC.xml
    └── measurement
    │   ├── IPC.xml
    │   └── measurementLikwid.xml
└── src
    ├── Algorithm.py
    ├── Fitness
        ├── DefaultFitness.py
        └── SimplicityTempFitness.py
    ├── Individual.py
    ├── Instruction.py
    ├── Measurement
        ├── Measurement.py
        ├── MeasurementIPC.py
        └── MeasurementLikwidPower.py
    ├── Operand.py
    ├── Population.py
    ├── __init__.py
    └── parseGeneticResults.py


/.gitignore:
--------------------------------------------------------------------------------
1 | 
2 | *.pyc
3 | 


--------------------------------------------------------------------------------
/.project:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <projectDescription>
 3 | 	<name>GeST</name>
 4 | 	<comment></comment>
 5 | 	<projects>
 6 | 	</projects>
 7 | 	<buildSpec>
 8 | 		<buildCommand>
 9 | 			<name>org.python.pydev.PyDevBuilder</name>
10 | 			<arguments>
11 | 			</arguments>
12 | 		</buildCommand>
13 | 	</buildSpec>
14 | 	<natures>
15 | 		<nature>org.python.pydev.pythonNature</nature>
16 | 	</natures>
17 | </projectDescription>
18 | 


--------------------------------------------------------------------------------
/.pydevproject:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8" standalone="no"?>
2 | <?eclipse-pydev version="1.0"?><pydev_project>
3 | <pydev_pathproperty name="org.python.pydev.PROJECT_SOURCE_PATH">
4 | <path>/${PROJECT_DIR_NAME}/src</path>
5 | </pydev_pathproperty>
6 | <pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 3.6</pydev_property>
7 | <pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">Default</pydev_property>
8 | </pydev_project>
9 | 


--------------------------------------------------------------------------------
/README:
--------------------------------------------------------------------------------
  1 | Copyright 2019 ARM Ltd. and University of Cyprus
  2 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, 
  3 | including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, 
  4 | and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
  5 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
  6 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
  7 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
  8 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  9 | 
 10 | 
 11 | AUTOMATIC FRAMEWORK FOR STRESS TEST GENERATION (GeST Generating Stress-Tests)
 12 | 
 13 | GENERAL DESCRIPTION
 14 | 
 15 | This framework is based on Genetic algorithms (GA) and it has been succesfully been used to develop power viruses (stres-tests that maximize power consumption), 
 16 | dI/dt viruses (stress-tests that maximize voltage noise) and IPC stress tests (maximize instruction per cycle throughput) on various CPUs such as ARM cortex-A15, cortex-A7,
 17 | cortex-A57,cortex-A53, cortex-A72, AMD Athlon II X4 645, X-Gene2, X-Gene3
 18 | 
 19 | GA optimize for the target metric using bio-inspired operators such as crossover (exchange of genes), mutation, selection of fittest individual for breeding (for crossover).
 20 | GA typically begins with a population of individuals (randomly generated) and evolves this population by measuring the fitness of the individuals and applying the aforementioned operators.
 21 | 
 22 | The framework produces assembly instructions sequences that are measured for the metric of interest (with a fitness function). The goal of the framework is to generate the fittest instruction sequence 
 23 | (in the GA terminology the fittest individual). 
 24 | For instance if the goal is maximum CPU power consumption the framework attempts to generate instruction sequences that maximize the power consumption.
 25 | 
 26 | The framework can be extended by the user to stress other components such as DRAM, Last level cache (Uncore) etc. Also it can be extended to support more complicate fitness functions that take in account 
 27 | multiple measurement metrics (power, pef counters etc) and instinsic instruction sequence characteristics such as instruction mix breakdown.
 28 | 
 29 | The framework also offers an easy interface to the user to add custom measurement procedures. 
 30 | Some template measurements are included in the framework such as maximizing max power using IPMI readings and maximizing IPC through perf counters on a ssh reachable machine.
 31 | But for instance if a user wants to maximize on a bare metal machine power using a specific power plug meter, he can write his own measurement function and seemlesly integrate it in the framework (read DEFINING CUSTOM MEASUREMENTS - CUSTOM FITNESS CLASSES and FUNCTIONS section).
 32 | 
 33 | The framework is written in Python 3 and xml is used for configuration files
 34 | 
 35 | REQUIREMENTS
 36 | 
 37 | The framework shoud work without any issues on Linux enviroment, but it has been tested only on Windows only with Eclipse IDE for development and running experiments. 
 38 | The following enviroment is recommended
 39 | 
 40 | 1) Windows OS
 41 | 2) LiClipse IDE
 42 | 3) Python 3.6 is recommended but probably any Python 3 would work (NOTE this is not compatible with python 2!!)
 43 | 4) NI-visa drivers must be installed if going to use measurement instruments such oscilloscopes and spectrum analyzer for measurements (tested with NI-VISA 5)
 44 | 5) Paramiko python libary and its dependencies must be installed for enabling ssh communication (execute from shell the command: pip install paramiko #pip is the python package manager ). Very useful coordinating execution on the target machine.
 45 | 6) Python PYVISA libary if going to use measurement instruments such oscilloscopes and spectrum analyzer for measurements
 46 | 
 47 | INSTALLATION INSTRUCTIONS on WINDOWS
 48 | 
 49 | 1) Download liclipse for python development https://www.liclipse.com/
 50 | 2) Download python 3 https://www.python.org/downloads/
 51 | 3) Locate pip binary. For python 3.6 should be found in C:\Users\UserName\AppData\Local\Programs\Python\Python36-32\python.exe
 52 |    From a windows terminal run   
 53 |    pip install paramiko
 54 |    pip install -U pyvisa #necessary if measurements with spectrum analyzers and oscilloscopes
 55 | 
 56 | 
 57 | RUN INSTRUCTIONS ON ECLIPSE/Liclipse
 58 | 
 59 | 1) Import the project as Python project
 60 | 2) Set correctly the configuration file (look section below)
 61 | 3) Right click on the project then debug-as. In the arguments section specify the full path to the configuration file you will use.
 62 | 
 63 | SET CORRECTLY THE CONFIGURATION FILE
 64 | This section explains how to set correctly the configuration file and we will explain this with a particular example.
 65 | Let's say you want to optimize for maximum power consumption on an x86 CPU using likwid power meter.
 66 | In this case you can use the following provided class and files: configuration_likwidPowerMeter.xml, measurementLikwid.xml and MeasurementLikwidPower.py.
 67 | Below are some steps you need to follow to set correctly the configuration files in relation to your environemnt. Similar steps should be followed for the IPC optimization (configuration files included in the release) 
 68 | any any other optimization you wish to perform.
 69 | 
 70 | 1) Open the configuration_likwidPowerMeter.xml
 71 | 2) Set the dirToSaveResults attribute to the path where you want the results to be saved.
 72 | 3) Set the compilationDir to the path where the assembly template compilation is located (the director where the main_original.s is located)
 73 | 4) Make sure the main_original.s has   a  #loop_code string which point to GeST where to print the individual. Add to the main_original.s any register and memory initilization you wish to have.
 74 | 5) Make sure that the measurementClass attribute is set to MeasurementLikwidPower, the measurementClassConfFile  is set to measurementLikwid and the fitnessClass to DefaultFitness
 75 | 6) On the target machine (the machine for which the virus is generated) create a temporary directory which will be used by the GA for compiling the individuals and placing temporary the 
 76 | individual's source code and binary.
 77 | 7) Open the measurement xml configuration file, in this particular example the file you need to open is the measurement/measurementLikwid.xml
 78 | 8) Set the targetRunDir with the path where GA temporary directory is located (the one created in step 6)
 79 | 9) Set the targetHostname attribute value to the ip or hostname with which the target machine is accessible through ssh
 80 | 10) Set the targetSSHusername and targetSSHpassword attributes. Make sure that with the username account you can run sudo commands without password. 
 81 | To achieve this make sure your account belongs to sudo group and if e.g. the target runs Ubuntu add this line "%sudo   ALL=(ALL:ALL) NOPASSWD:ALL " to the /etc/sudoers file. 
 82 | 11) Set the core ids that will be used in the optimization (that will run the indiviudal binary)
 83 | 12) Set the time_to_measure each individual. For power optimization with likwid we had good results with 5 seconds but ofcourse you are free to play with this variable.
 84 | 
 85 | MORE DETAILS ON HOW TO USE GEST
 86 | 
 87 | Detailed explanation of the main configuration file options is found in configuration-template-explanation.xml located in ./configurationFiles. 
 88 | Also we recommend to read the ISPASS 2019 paper "GeST an automatic framework for generating CPU stress-tests" https://ieeexplore.ieee.org/document/8695639  which is a good reading to understand the framework and how to use it.
 89 | 
 90 | To get more information on how to use GeST and what capabilities it offers please continue reading.
 91 | 
 92 | GeST gives you the ability:
 93 | a)  To play with some algorithm parameters e.g. mutation, crossover,loop sizes, population size etc
 94 | b)  To specify explicity what instructions or even instruction sequences you want to use in the optimization process. 
 95 | c)  Specify operands and which instructions will use those operands which eventually give you the ability to force or not force dependencies between instructions
 96 | d)  You can specify fixed code segments which will be present in all the individuals (an individual is an instruction sequence generated) e.g. some check for not touching illegal memory, register and memory initialization   
 97 | e)  Make a run starting with fixed instruction mix breakdwon
 98 | f)  Ability to save a run and continue it after
 99 | g)  Different measurement procedures by defining your own manual class that inherits from the Measurement/Mesurement.py class. 
100 |     You don't need to change anything else in the code just specify the custom measurement class name in the configuration file.
101 | h)  Different fitness functions by defining your own manual class that inherits from the Fitness/DefaultFitness.py class
102 |     You don't need to change anything else in the code just specify the custom measurement class name in the configuration file.
103 |     
104 | CONFIGURATION FILES LOCATION
105 | The main configuarion files should be placed in ./configurationFiles folder. Configuration related to custom measurement classes should be placed in ./configurationFiles/measurement directory
106 | 
107 | ASSEMBLY COMPILATION DIRECTORY
108 | The dirs with prefix assembly_compilation are the dirs which contain all the necessary files for the generation of the binary that is going to be run on the target machine. 
109 | You must specify which dir you are going to use for the compilation in the configuration file. 
110 | The assembly compilation dir in the most simple form contains one source file that will be compiled, namely the main_original.s 
111 | The main_orginal.s must contain a line which contains the string “#loop_code”. This string will be replaced by the generated by framework code sequence. 
112 | Any memory, register initialization or in general common fixed code accross all individuals can be placed on the main_original.s file
113 | 
114 | FRAMEWORK OUTPUT RESULTS
115 | The dirToSaveResults parameters which is set in the configuration.xml file specifies the directory in which results – outputs of the framework run will be saved. 
116 | In this directory you can find the generated code sequences which will be save in ascii format in .txt files. The name format of each file goes like this populationNumber_individualsIdNumber_measurement1_measurement2_etc. 
117 | You can specify as many measurements as you want. Also a dir which is named after the date/time of the start of the run is created e.g. (13-12-10-15-06 means the run started on 13th of December at 15-06). This dir will contain each population saved in .pkl file and the rand state (also in .pkl format) at each population. 
118 | This dir can be used as a seed dir in case you want to continue an unfinished run. So basically each run leaves a seed dir behind. (Note to start a run from an existing SeedDir set the seedDir parameter in the configuration file)
119 | In the seed dir the assembly compilation file is copied.  All the compilations and modifications of the code happen on that copied assembly compilation file which is located in the seed dir.  
120 | In the seed dir also is copied the configuration.xml and measurement.xml file and the src of the framework which was used for that run.
121 | The population pkl files can be used for parsing results. After measuring a population the whole population is saved in a .pkl file. 
122 | The populations are saved in ascending order like this 1.pkl, 2.pkl 3.pkl and etc. The parseGeneticResults.py file is an example of how to parse the population files and get statistics about average and best of each generation as well as the average and best individual’s instruction mix for each population.  
123 | To use the script just pass the seed dir’s absolute path as argument.  
124 | 
125 | DEFINING CUSTOM MEASUREMENTS - CUSTOM FITNESS CLASSES and FUNCTIONS
126 | Framework allows definining custom measurement classes and fitness functions. 
127 | The measurement procedure is a a very environment specific procedure. A GA stress-test generation framework must support IPC, thermal, power, etc. optimizations. 
128 | Moreover, for instance, to optimize for power consumption various power measurment tools might be used such as IPMI, RAPL etc. 
129 | Due to so many alternatives a framework that supports all these alternatives is impossible to create. 
130 | Hence, we provide a simple interface to the user to write it's own measurement procedures and use them with this framework. Templates of measurement classes can be found in ./Measurement directory and
131 | the representative configuration files in ./configurationFiles/measurement directory. To add your own measurement class create a class that inherits from Measurement.py and place it ./Measurement directory. 
132 | You have to overwrite the measure function and most likely you
133 | will also need to overwite the init function to read any custom parameters required by your class. The custom parameters need to be specified in a configuration file placed in ./configurationFiles/measurement. 
134 | You don't need to touch any other framework's code to use your measurement class. Just add in the main configuration file the name of the class and the name of the classe's configuration file (just the name not the full path) in the  
135 | measurementClass and measurementClassConfFile parameters. 
136 | This is achieved with Python's capability to dynamically load a class (without specifing it during source compilation). 
137 | 
138 | You can also modify the fitness function with the same principles as for the Measurement class.
139 | You can do this by inheriting from the DefaultFitness class and overriding the getFitness function. The fitness function takes as parameter the individual after is being measurement. The individual object comes with
140 | its instruction sequence and its measurements. The default getFitness function just returns the first measurement as the fitness value, e.g. it can be the average power while running the individual. 
141 | You have to place the custom fitness class in the  ./Fitness directory. To
142 | use your custom fitness class specify the name in the fitnessClass parameter in the configuration file. 
143 | For now Fitness classes does not come with a configuration file like measurement classes. 
144 | If needed this might be changed in the future.  
145 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # GeST
2 | 
3 | GeST (Generating Stress-Tests) is a framework for automatic hardware stress-test generation.
4 | 
5 | A scientific paper about GeST is published in ISPASS 2019 https://ieeexplore.ieee.org/document/8695639 
6 | 
7 | Hadjilambrou, Z., Das, S., Whatmough, P.N., Bull, D. and Sazeides, Y., 2019, April. GeST: An Automatic Framework For Generating CPU Stress-Tests. In 2019 IEEE International Symposium on Performance Analysis of Systems and Software (ISPASS) (pp. 1-10). IEEE.
8 | 


--------------------------------------------------------------------------------
/assembly_compilation_ARM/main_original.s:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright 2019 ARM Ltd. and University of Cyprus
  3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, 
  4 | including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, 
  5 | and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
  6 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
  7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
  8 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
  9 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 10 | */
 11 | 	.data
 12 | 
 13 | msg:
 14 | 	.ascii	"\n"
 15 | len = . - msg
 16 | 	.text
 17 | 	.align 2
 18 | 	.global main
 19 | 	.type main, %function
 20 | 
 21 | 
 22 | 
 23 | main:
 24 | 
 25 | #reg init
 26 | 
 27 |     LDR x0,=0xAAAAAAAA 
 28 |     LDR x1,=0x55555555 
 29 |     LDR x2,=0x00000000  
 30 |     LDR x3,=0x00000000 
 31 |     LDR x4,=0x55555555  
 32 |     LDR x5,=0x33333333 
 33 |     LDR x6,=0xFFFFFFFF  
 34 |     LDR x7,=0xFFFFFFFE 
 35 |     LDR x8,=0x00000001  
 36 |     LDR x9,=0xCCCCCCCC
 37 |     LDR x10,=0xAAAAAAAA 
 38 |     LDR x11,=0x55555555 
 39 |     LDR x12,=0x00000000  
 40 |     LDR x13,=0x00000000 
 41 |     LDR x14,=0x55555555  
 42 |     LDR x15,=0x33333333 
 43 |     LDR x16,=0xFFFFFFFF  
 44 |     LDR x17,=0xFFFFFFFE 
 45 |     LDR x18,=0x00000001  
 46 |     LDR x19,=0xCCCCCCCC 
 47 |     LDR x20,=0xAAAAAAAA 
 48 |     LDR x21,=0x55555555 
 49 |     LDR x22,=0x00000000  
 50 |     LDR x23,=0x00000000 
 51 |     LDR x24,=0x55555555  
 52 |     LDR x25,=0x33333333 
 53 |     LDR x26,=0xFFFFFFFF  
 54 |     LDR x27,=0xFFFFFFFE 
 55 |     LDR x28,=0x00000001  
 56 |     LDR x29,=0xCCCCCCCC
 57 |     LDR x30,=0xCCCCCCCC  
 58 |     LDR D0,=0xAAAAAAAAAAAAAAAA 
 59 |     LDR D1,=0xFFFFFFFFFFFFFFFF   
 60 |     LDR D2,=0x5555555555555555   
 61 |     LDR D3,=0x3333333333333333   
 62 |     LDR D4,=0xCCCCCCCCCCCCCCCC   
 63 |     LDR D5,=0x0000000100000001   
 64 |     LDR D6,=0xFFFFFFFEFFFFFFFE   
 65 |     LDR D7,=0x0000000000000000   
 66 |     LDR D8,=0xAAAAAAAA55555555   
 67 |     LDR D9,=0x55555555AAAAAAAA
 68 |     LDR D10,=0xAAAAAAAAAAAAAAAA 
 69 |     LDR D11,=0xFFFFFFFFFFFFFFFF  
 70 |     LDR D12,=0x5555555555555555  
 71 |     LDR D13,=0x3333333333333333  
 72 |     LDR D14,=0xCCCCCCCCCCCCCCCC  
 73 |     LDR D15,=0x0000000100000001  
 74 |     LDR D16,=0xFFFFFFFEFFFFFFFE  
 75 |     LDR D17,=0x0000000000000000  
 76 |     LDR D18,=0xAAAAAAAA55555555  
 77 |     LDR D19,=0x55555555AAAAAAAA
 78 |     LDR D20,=0xAAAAAAAAAAAAAAAA 
 79 |     LDR D21,=0xFFFFFFFFFFFFFFFF  
 80 |     LDR D22,=0x5555555555555555  
 81 |     LDR D23,=0x3333333333333333  
 82 |     LDR D24,=0xCCCCCCCCCCCCCCCC  
 83 |     LDR D25,=0x0000000100000001  
 84 |     LDR D26,=0xFFFFFFFEFFFFFFFE  
 85 |     LDR D27,=0x0000000000000000  
 86 |     LDR D28,=0xAAAAAAAA55555555  
 87 |     LDR D29,=0x55555555AAAAAAAA
 88 |     LDR D30,=0x55555555AAAAAAAA
 89 |     
 90 | 
 91 | 
 92 | 	LDR x12,=0x200
 93 | 	#0x200 is 512 bytes
 94 | 	SUB x12,sp,x12
 95 | 	MOV x10,x12
 96 | 	MOV x11,10
 97 | 	#x12 will hold the end address
 98 |     
 99 |     LDR x28, =0x3B9ACA00/*1 billion iterations. x28 to be used for iteration counter if running for fixed iterations*/
100 |     
101 | Start:
102 | 
103 | 
104 |     #loop_code
105 | 
106 | 
107 | 
108 | 
109 | b Start
110 | 		
111 | 	#SUB x28,x28,1 #uncomment for running for fixed iterations
112 | 	#CBNZ x28,Start
113 | 		
114 | ret
115 | .size	main, .-main
116 | .ident	"GCC: (APM-8.0.10-le) 4.9.3 20150218 (prerelease)"
117 | .section	.note.GNU-stack,"",%progbits
118 | 


--------------------------------------------------------------------------------
/assembly_compilation_x86_gcc/main_original.s:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright 2019 ARM Ltd. and University of Cyprus
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, 
 4 | including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, 
 5 | and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 6 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 8 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
 9 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
10 | */
11 | 
12 |         .file   "main.s"
13 |         .data
14 |         .align 32
15 |         .simdvalue:
16 |             .long   0xaaaaaaaa
17 |             .long   0x55555555
18 |             .long   0x33333333
19 |             .long   0xcccccccc
20 |             .long   0xaaaaaaaa
21 |             .long   0x55555555
22 |             .long   0x33333333
23 |             .long   0xcccccccc
24 |         .text
25 |         .globl  main
26 |         main:
27 | .LFB0:
28 |         .cfi_startproc
29 |         pushq   %rbp
30 |         .cfi_def_cfa_offset 8
31 |         .cfi_offset 5, -8
32 |         movl    %esp, %ebp
33 |         .cfi_def_cfa_register 5
34 | 
35 | 
36 | 
37 |         #reg init
38 | 
39 | 
40 |         mov $0x55555555, %rax
41 |         mov $0x33333333, %rbx
42 |         mov $0x22222222, %rdx
43 |         mov $0x44444444, %rsi
44 |         mov $0x77777777, %rdi
45 | 
46 |         fldpi
47 |         fldpi
48 |         fldpi
49 |         fldpi
50 |         fldpi
51 |         fldpi
52 |         fldpi
53 |         
54 |         vmovdqa .simdvalue(%rip), %ymm0
55 |         vmovdqa .simdvalue(%rip), %ymm1
56 |         vmovdqa .simdvalue(%rip), %ymm2
57 |         vmovdqa .simdvalue(%rip), %ymm3
58 |         vmovdqa .simdvalue(%rip), %ymm4
59 |         vmovdqa .simdvalue(%rip), %ymm5
60 |         vmovdqa .simdvalue(%rip), %ymm6
61 |         vmovdqa .simdvalue(%rip), %ymm7
62 |         vmovdqa .simdvalue(%rip), %ymm8
63 |         vmovdqa .simdvalue(%rip), %ymm9
64 |         vmovdqa .simdvalue(%rip), %ymm10
65 |         vmovdqa .simdvalue(%rip), %ymm11
66 |         vmovdqa .simdvalue(%rip), %ymm12
67 |         vmovdqa .simdvalue(%rip), %ymm13
68 |         vmovdqa .simdvalue(%rip), %ymm14
69 |         vmovdqa .simdvalue(%rip), %ymm15
70 | 
71 |         mov $50000000, %rcx  #leave for i--
72 | 
73 |         #subq    $304, %rsp
74 | 
75 | .L2:
76 |       
77 | #loop_code
78 | 
79 | 
80 |         #sub $1,%rcx #remove this and below comment for fixed iterations
81 |         #cmp $0, %rcx
82 |         jmp     .L2
83 | 
84 |          leave
85 |         .cfi_restore 5
86 |         .cfi_def_cfa 4, 4
87 |        ret
88 | 
89 |         .cfi_endproc
90 | .LFE0:
91 |         .ident  "GCC: (GNU) 6.4.0"
92 | 


--------------------------------------------------------------------------------
/configurationFiles/configuration-template-explanation.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <!-- 
  3 | Copyright 2019 ARM Ltd. and University of Cyprus
  4 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, 
  5 | including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, 
  6 | and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
  7 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
  8 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
  9 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
 10 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 11 | -->
 12 | <GA_inputs>
 13 |   <general_inputs>
 14 | 
 15 |     
 16 |     <!--General GA inputs-->
 17 |     
 18 |     <loopSize value="50"/> <!--The size in instructions of the generated code sequences-->
 19 |     <population_size value="50"/> <!-- The size of each population - generation-->
 20 |     <mutation_rate value="0.02"/> <!-- each instruction will have this probability to be mutated (changed to something else)-->
 21 |     <crossover_type value="1"/>
 22 |     <!--0 for uniform crossover, 1 for one point crossover. This is a good article that explains the crossover types http://en.wikipedia.org/wiki/Crossover_(genetic_algorithm). I have implemented 
 23 |     only two crossover types the uniform and the 1 point. For generating stress tests I found that 1 point crossover is better since strong instructions sequences have higher chance to survive-->
 24 |     <crossover_rate value="1.0"/>
 25 |     <!--The chance two parent two recombine.. usually is a very high percentage-->
 26 |     <uniform_rate value="0.5"/>
 27 |     <!--Only used when uniform crossover is set... The chance for each instruction to be crossovered-->
 28 |     
 29 |     <!-- for how many populations (generations to run the GA).. In practice most of the time we don't really bother with this variable.. Just set it to very high number and manually stop the GA when the results seem good enough or GA doesn't improve anymore.. -->
 30 |     <populations_to_run  value="1000"></populations_to_run>
 31 |     
 32 |     <ellitism value="true"/> <!-- true or false. If true the best individual is promoted to the next generation. I think keeping this to "true" is good choice-->
 33 | 
 34 |     <selectionMethod value="0" />
 35 |     <!-- 0 for tournament 1 for wheel selection. Only those two are implemented... wheel selection doesn't work really well so I propose tournament. If you want to learn about wheel selection here http://en.wikipedia.org/wiki/Fitness_proportionate_selection-->
 36 |     <tournament_size value="5" />
 37 |     <!--Only useful with tournament selection. 5 worked well for me but sure feel free to play with this variable more here http://en.wikipedia.org/wiki/Tournament_selection -->
 38 | 
 39 |     <instruction_percentage_clue value="False" /> <!-- your initial population will start with a fix number of different instruction types e.g. 50% neon 25% mem and 25% short latency.. If you know a good instruction mix it may
 40 |      speedup the algorithm convergence. True/False case-sensitive-->
 41 |     
 42 |     <!--end of general GA inputs-->
 43 |     
 44 |     <save_whole_source value="1" /> <!-- choose whether to save the whole individual src code or just the loop instructions.. saving the whole source takes ~4X more disk space but is also more convenient --> 
 45 |                                     <!-- when this is 0 to reproduce the src code of an individual copy paste the loop instructions into the template source file (main_original.s) located in compilationDir-->
 46 |     
 47 |     <measurementClass value="IPC" /> <!--Enter the name of the class located in the src\Measurement folder that will be used for measurements-->
 48 |     <measurementClassConfFile value="" /> <!-- enter the name of the configuraiton file for the measurement class.. the file must be located in configurationFiles/measurement directory-->
 49 |     <!--Input/output dir-->
 50 |     <dirToSaveResults
 51 |       value="C:/GAruns/ExampleRun"
 52 |     /> <!-- The code sequeneces will be save in ascii format in .txt files in the specified dir. The name format of each file goes like this populationNumber_individualsIdNumber_fitnessValue_measurement1_.... Also a dir which is named
 53 |     after the date/time of the start of the run is created. This dir will contain each population saved in .pkl file and the rand state (also in .pkl format) at each population. This dir can be used as seed dir in case you want to continue an unfinished run. 
 54 |     Also the contents of this dir can be used for parsing results. The parseGeneticResults.py is an example of how to parse the population files and get statistics -->
 55 |   
 56 |     <seedDir
 57 |       value=""
 58 |     />
 59 |     <!--Use the seedDir if you only want to begin algorithm from some specific indivduals instead of random population. In case you don't want to use this just put "". Otherwise point to the dir that contains the pkl files.. look the dirToSaveResults attribute for more details -->
 60 |    
 61 |        <fitnessClass value='DefaultFitness' /> <!--Enter the name of the class located in the src\Fitness folder that will be used for calculating the fitness of individuals-->
 62 |     
 63 |     <compilationDir
 64 |       value="C:/GeST/assembly_compilation/"
 65 |       /> <!-- Dir where the compilation code is located .. IMPORTANT the main_original.s must always contain a line #loop_code. At that line
 66 |       the framework will bring in the generated code sequence.. In main_original.s and startup_original.s you can place all the code that you want to be common between each individual e.g. memory and register initialization... 
 67 |       Actually the only thing that will differ among each individual run
 68 |       should be the individual's code sequence which is placed under the "#loop_code" line-->
 69 | 
 70 |     <!--End of Input/output dir-->
 71 | 
 72 |     
 73 |   </general_inputs>
 74 | 
 75 |   <instruction_types> <!--Specify intruction types and how much will be the amount of each type in the loop.. The percentage will be considered only if the instruction_percentage_clue is set to "True"-->
 76 |     
 77 |     <!-- how much percentage of each kind of instructions type the loop will consist of.. -->
 78 |     <instruction_type
 79 |       id="shortLat"
 80 |       perc="0.08"
 81 |     />
 82 | 
 83 |     <instruction_type
 84 |       id="longLat"
 85 |       perc="0.1"
 86 |     />
 87 | 
 88 |     <instruction_type
 89 |       id="neonVfp"
 90 |       perc="0.44"
 91 |     />
 92 |     
 93 |      <instruction_type
 94 |       id="floatingPoint"
 95 |       perc="0.44"
 96 |     />
 97 | 
 98 |     <instruction_type
 99 |       id="mem"
100 |       perc="0.36"
101 |     />
102 | 
103 |     <instruction_type
104 |       id="branch"
105 |       perc="0.02"
106 |     />
107 | 
108 |   
109 |   </instruction_types>
110 |     
111 |     <instructions_operands>
112 |     
113 |     <!-- In this section you define all operands that are going to be used by the instructions.. In this section you must define different type of registers e.g. integer registers and float register, branch labels
114 |     immediate values and memory subscripts.. Basically you must define whatever comes after an instruction name and you want to be touched by the evolution process of the algorithm-->
115 |     
116 |     <!--For each operand you must define an id.. the possible values the operand can take.. and the type of operand... 
117 |     the algorithm understands and treats differently 3 types of operands 
118 |     1)registers, 2)constant values(e.g. #4 in LDR x0,[x1,#4]), and 3) immediate values (same thing as constant values)
119 |     The type must be specified in the type attribute ath the operand definition (examples below)
120 |     
121 |     The immediate/constant operand's values can be specified with the min max and stride parameters
122 |         
123 |         <operand
124 |     id="mem_address_subscript"
125 |     min="0"
126 |     max="4092"
127 |     stride="4"
128 |     type="constant"
129 |     toggle="False">
130 |     </operand>
131 |    
132 |    while registers are specified through values parameter e.g.
133 |    
134 |           <operand
135 |     id="simd_register"
136 |     values="v0.4s v1.4s v2.4s v3.4s v4.4s v5.4s v6.4s v7.4s v8.4s v9.4s v10.4s v11.4s"
137 |     type="register"
138 |      toggle="False">
139 |     </operand>
140 |    
141 |     Toggling flag is broken don't use it
142 |     
143 |     -->
144 |     
145 |         <operand
146 |     id="simd_register"
147 |     values="v0.4s v1.4s v2.4s v3.4s v4.4s v5.4s v6.4s v7.4s v8.4s v9.4s v10.4s v11.4s"
148 |     type="register"
149 |      toggle="False">
150 |     </operand>
151 |     
152 |     <operand
153 |    id="integer_register"
154 |    values="x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x29 x30"
155 |    type="register"
156 |    toggle="False">
157 |     </operand>
158 |     
159 |      <operand
160 |    id="integer_result_register"
161 |    values="x0"
162 |    type="register"
163 |    toggle="False">
164 |     </operand>
165 |     
166 |      <operand
167 |    id="word_register"
168 |    values="w0 w1 w3 w4 w5 w6 w7 w8 w9 w13 w14 w15 w16 w17 w18 w19 w20 w21 w22 w23 w24 w25 w26 w27 w28 w29 w30"
169 |    type="register"
170 |    toggle="False">
171 |     </operand>
172 | 
173 | 
174 |     <operand
175 |  id="mem_result"
176 |  values="x2" 
177 |  type="register"
178 |  toggle="False"
179 |    >
180 |     </operand> <!-- dont include this in integer registers to avoid stalls due to memory.. at least for high IPC target, max power and etc -->
181 | 
182 |    <operand
183 |    id="mem_result2"
184 |    values="x3"
185 |    type="register"
186 |    toggle="False"
187 |    >
188 |     </operand>  
189 | 
190 |     <operand
191 |  id="mem_str"
192 |  values="x6"
193 |  type="register"
194 |  toggle="False"
195 |    >
196 |     </operand>
197 | 
198 |    <operand
199 |    id="mem_str2"
200 |    values="x7"
201 |    type="register"
202 |    toggle="False"
203 |    >
204 |     </operand> 
205 | 
206 |     <operand
207 |   id="float_register"
208 |   values="s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 s11 s12"
209 |   type="register"
210 |    toggle="False">
211 |     </operand>
212 |     <operand
213 |     id="double_register"
214 |     values="d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 d10 d11 d12 d13 d14 d15 d16 d17 d18 d19 d20 d21 d22 d23 d24 d25 d26 d27 d28 d29 d30"
215 |     type="register"
216 |      toggle="False">
217 |     </operand>
218 |     
219 |     
220 | 
221 |     <operand
222 |     id="double_mem_res1"
223 |     values="d10"
224 |     type="register"
225 |      toggle="False">
226 |     </operand>
227 | 
228 |     <operand
229 |     id="double_mem_res2"
230 |     values="d11"
231 |     type="register"
232 |      toggle="False">
233 |     </operand>
234 | 
235 |     <operand
236 | id="double_mem_str1"
237 | values="d12"
238 | type="register"
239 |  toggle="False">
240 |     </operand>
241 | 
242 |     <operand
243 | id="double_mem_str2"
244 | values="d13"
245 | type="register"
246 |  toggle="False">
247 |     </operand>
248 | 
249 |     <operand
250 |    id="quad_register"
251 |    values="q1 q2 q3 q4 q5 q6 q7 q8 q9 q10 q11 q12"
252 |    type="register"
253 |     toggle="False">
254 |     </operand>
255 |     
256 | 
257 |     <operand
258 |      id="l1_miss_address_register"
259 |      values="x11"
260 |      type="register"
261 |      toggle="False">
262 |     </operand>
263 | 
264 |     <operand
265 |     id="mem_address_register"
266 |     values="x10"
267 |     type="register"
268 |     toggle="False">
269 |     </operand>
270 | 
271 | 
272 |     <operand
273 |     id="shift_value"
274 |     min="31"
275 |     max="31"
276 |     stride="1"
277 |     type="constant"
278 |     toggle="False">
279 |     </operand>
280 | 
281 | 
282 |     <operand
283 |     id="constant_value"
284 |     min="0"
285 |     max="4092"
286 |     stride="4"
287 |     type="constant"
288 |     toggle="False">
289 |     </operand>
290 | 
291 | 
292 |     <operand
293 |    id="constant_value2"
294 |    min="0"
295 |    max="256"
296 |    stride="8"
297 |    type="constant"
298 |    toggle="False">
299 |     </operand>
300 | 
301 |     <operand
302 |   id="constant_value_vector"
303 |   min="0"
304 |   max="1020"
305 |   stride="4"
306 |   type="constant"
307 |   toggle="False">
308 |     </operand>
309 | 
310 |     <operand
311 |   id="constant_value3"
312 |   min="256"
313 |   max="256"
314 |   stride="8"
315 |   type="constant"
316 |   toggle="False">
317 |     </operand>
318 |     
319 |     
320 |     <operand
321 |   id="constant_value4"
322 |   min="0"
323 |   max="256"
324 |   stride="16"
325 |   type="constant"
326 |   toggle="False">
327 |     </operand>
328 | 
329 | 
330 |     
331 |   </instructions_operands>
332 | 
333 |   <instructions>
334 | 
335 |     <!--In this section you will specify the instructions you want the framework to use in the optimization
336 |     process.. -->
337 | 
338 |     <!-- Lets understand how to decalare an instruction by explaining the following example
339 |     
340 |        <instruction
341 |       name="ADD"
342 |       num_of_operands="3"
343 |       type="shortLat"
344 |        operand1="integer_register"
345 |         operand2="integer_register"
346 |        operand3="integer_register"
347 |         format="ADD op1,op2,op3"
348 |       toggle="False">
349 |     </instruction> 
350 |     
351 |      The name attribute is basically the unique indentifier of this instruction, usually you will be fine by just putting the instruction name (like in the example ADD)... 
352 |     The num of operands and type attributes are pretty auto-explainable
353 |     Note that each instruction must belong to an instruction type which was defined in the instruction_type section. As you can see in the example the instruction belongs to shortLatency instruction type
354 |     
355 |     For operand1, operand2 and etc you must specify an operand id that exists in the instructions_operands section.. 
356 |     In the format attribute put the string that represents the syntax of the instruction. op1, op2 and op3 point out to the place where each instruction's operand should be. 
357 |     don't bother with toggle attribute is broken
358 |     -->
359 | 
360 |     
361 | 
362 |   <instruction
363 |       name="ADDS"
364 |       num_of_operands="3"
365 |       type="shortLat"
366 |        operand1="integer_register"
367 |       operand2="integer_register"
368 |      operand3="integer_register"
369 |       format="ADDS op1,op2,op3"
370 |       toggle="False">
371 |     </instruction> 
372 |     
373 |     <!-- short int-->
374 |     
375 |     <instruction
376 |       name="ADD"
377 |       num_of_operands="3"
378 |       type="shortLat"
379 |        operand1="integer_register"
380 |       operand2="integer_register"
381 |      operand3="integer_register"
382 |       format="ADD op1,op2,op3"
383 |       toggle="False">
384 |     </instruction>
385 | 
386 | 
387 |     <instruction
388 |   name="LSL"
389 |   num_of_operands="3"
390 |   type="shortLat"
391 |   format="LSL op1,op2,#op3"
392 |   operand1="integer_register"
393 |    operand2="integer_register"
394 |    operand3="shift_value"
395 |   toggle="False">
396 |     </instruction>
397 | 
398 |     <instruction
399 |  name="ASR"
400 |  num_of_operands="3"
401 |  type="shortLat"
402 |  format="ASR op1,op2,#op3"
403 |  operand1="integer_register"
404 |   operand2="integer_register"
405 |   operand3="shift_value"
406 |  toggle="False">
407 |     </instruction>
408 | 
409 |     <instruction
410 |     name="ROR"
411 |     num_of_operands="3"
412 |     type="shortLat"
413 |     format="ROR op1,op2,#op3"
414 |         operand1="integer_register"
415 |     operand2="integer_register"
416 |     operand3="shift_value"
417 |    toggle="False">
418 |     </instruction>
419 |     
420 |         <instruction
421 |   name="SUB"
422 |   num_of_operands="3"
423 |   type="shortLat"
424 |   operand1="integer_register"
425 |     operand2="integer_register"
426 |    operand3="integer_register"
427 |   format="SUB op1,op2,op3"
428 |   toggle="False">
429 |     </instruction>
430 | 
431 |     <instruction
432 |   name="MOV"
433 |   num_of_operands="2"
434 |   type="shortLat"
435 |   format="MOV op1,op2"
436 | operand1="integer_register"
437 |   operand2="integer_register"
438 |   toggle="False"
439 |       >
440 |     </instruction>
441 |     
442 |     <!-- long int-->
443 |     
444 |      <instruction
445 |       name="MUL"
446 |       num_of_operands="3"
447 |       type="longlat"
448 |       operand1="integer_register"
449 |       operand2="integer_register"
450 |       operand3="integer_register"
451 |         format="MUL op1,op2,op3"
452 |       toggle="False">
453 |     </instruction> 
454 |     
455 |     <!-- memory -->
456 |     
457 |  <instruction
458 |   name="STP"
459 |   num_of_operands="4"
460 |   type="mem"
461 |   format="STP op1,op2,[op3,#op4]"
462 |   operand1="integer_register"
463 |   operand2="integer_register"
464 |   operand3="mem_address_register"
465 |   operand4="constant_value2"
466 |   toggle="False"
467 |       >
468 |     </instruction>
469 | 
470 |  <instruction
471 |   name="STR"
472 |   num_of_operands="3"
473 |   type="mem"
474 |   format="STR op1,[op2,#op3]"
475 |   operand1="integer_register"
476 |   operand2="mem_address_register"
477 |   operand3="constant_value4"
478 |   toggle="False"
479 |       >
480 |     </instruction>
481 |  
482 | 
483 |     <instruction
484 |     name="LDP"
485 |     num_of_operands="4"
486 |     type="mem"
487 |     format="LDP op1,op2,[op3,#op4]"
488 |     operand1="mem_result"
489 |     operand2="mem_result2"
490 |     operand3="mem_address_register"
491 |     operand4="constant_value2"
492 |     toggle="False"
493 |       >
494 |     </instruction>
495 |     
496 |         <instruction
497 |     name="LDR"
498 |     num_of_operands="3"
499 |     type="mem"
500 |     format="LDR op1,[op2,#op3]"
501 |     operand1="integer_register"
502 |     operand2="mem_address_register"
503 |     operand3="constant_value2"
504 |     toggle="False"
505 |       >
506 |     </instruction>
507 |   
508 |   
509 |   <instruction
510 |   name="SCVTF"
511 |     num_of_operands="2"
512 |     type="floatingPoint"
513 |     format="SCVTF op1,op2"
514 |     operand1="double_register"
515 |     operand2="integer_register"
516 |     toggle="False"
517 |       >
518 |   </instruction>
519 |   
520 |     <!-- float point-->
521 |     
522 |         <instruction
523 | name="FCMP"
524 | num_of_operands="2"
525 | type="floatingPoint"
526 | format="FCMP op1,op2"
527 | operand1="double_register"
528 | operand2="double_register"
529 |  toggle="False">
530 |     </instruction>
531 | 
532 |     <instruction
533 | name="FMOV"
534 | num_of_operands="2"
535 | type="floatingPoint"
536 | format="FMOV op1,op2"
537 | operand1="double_register"
538 | operand2="double_register"
539 |  toggle="False">
540 |     </instruction>
541 |     
542 |    
543 |         
544 |     <instruction
545 | name="FMLA"
546 | num_of_operands="3"
547 | type="simd"
548 | format="FMLA op1,op2,op3"
549 | operand1="simd_register"
550 | operand2="simd_register"
551 | operand3="simd_register"
552 |  toggle="False">
553 |     </instruction>
554 |     
555 |     
556 |    <instruction
557 | name="FMUL"
558 | num_of_operands="3"
559 | type="simd"
560 | format="FMUL op1,op2,op3"
561 | operand1="simd_register"
562 | operand2="simd_register"
563 | operand3="simd_register"
564 |  toggle="False">
565 |     </instruction>
566 |     
567 |         
568 |                 <instruction
569 | name="FADD"
570 | num_of_operands="3"
571 | type="simd"
572 | format="FADD op1,op2,op3"
573 | operand1="simd_register"
574 | operand2="simd_register"
575 | operand3="simd_register"
576 |  toggle="False">
577 |     </instruction>
578 | 
579 | 
580 | <instruction
581 | name="FMUL"
582 | num_of_operands="3"
583 | type="floatingPoint"
584 | format="FMUL op1,op2,op3"
585 | operand1="double_register"
586 | operand2="double_register"
587 | operand3="double_register"
588 |  toggle="False">
589 |     </instruction>
590 | 
591 |     <instruction
592 |    name="FADD"
593 |    num_of_operands="3"
594 |    type="floatingPoint"
595 |    format="FADD op1,op2,op3"
596 |    operand1="double_register"
597 |    operand2="double_register"
598 |    operand3="double_register"
599 |     toggle="False">
600 |     </instruction>
601 | 
602 |   </instructions>
603 | 
604 | </GA_inputs>


--------------------------------------------------------------------------------
/configurationFiles/configuration_ARM_IPC.xml:
--------------------------------------------------------------------------------
  1 | <!-- 
  2 | Copyright 2019 ARM Ltd. and University of Cyprus
  3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, 
  4 | including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, 
  5 | and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
  6 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
  7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
  8 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
  9 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 10 | -->
 11 | <GA_inputs>
 12 | <general_inputs>
 13 | 
 14 |     
 15 | <!--General GA inputs-->
 16 |     
 17 | <loopSize value="50"/> <!--The size in instructions of the generated code sequences-->
 18 | <population_size value="50"/> <!-- The size of each population - generation-->
 19 | <mutation_rate value="0.02"/> <!-- each instruction will have this probability to be mutated (changed to something else)-->
 20 | <crossover_type value="1"/>
 21 | <!--0 for uniform crossover, 1 for one point crossover. This is a good article that explains the crossover types http://en.wikipedia.org/wiki/Crossover_(genetic_algorithm). I have implemented 
 22 | only two crossover types the uniform and the 1 point. For generating stress tests I found that 1 point crossover is better since strong instructions sequences have higher chance to survive-->
 23 | <crossover_rate value="1.0"/>
 24 | <!--The chance two parent two recombine.. usually is a very high percentage-->
 25 | <uniform_rate value="0.5"/>
 26 | <!--Only used when uniform crossover is set... The chance for each instruction to be crossovered-->
 27 | 
 28 | <populations_to_run value="1000"/>
 29 | <ellitism value="true"/>
 30 |  <!--
 31 |  true or false. If true the best individual is promoted to the next generation. I think keeping this to "true" is good choice
 32 | -->
 33 | <selectionMethod value="0"/>
 34 |  <!--
 35 |  0 for tournament 1 for wheel selection. Only those two are implemented... wheel selection doesn't work really well so I propose tournament. If you want to learn about wheel selection here http://en.wikipedia.org/wiki/Fitness_proportionate_selection
 36 | -->
 37 | <tournament_size value="5"/>
 38 |  <!--
 39 | Only useful with tournament selection. 5 worked well for me but sure feel free to play with this variable more here http://en.wikipedia.org/wiki/Tournament_selection 
 40 | -->
 41 | <save_whole_source value="1"/>
 42 |  <!--
 43 |  choose whether to save the whole individual src code or just the loop instructions.. saving the whole source takes ~4X more disk space but is also more convenient 
 44 | -->
 45 |  <!--
 46 |  when this is 0 to reproduce the src code of an individual copy paste the loop instructions into the template source file (main_original.s) located in compilationDir
 47 | -->
 48 | <measurementClass value="MeasurementIPC"/>
 49 |  <!--
 50 | Enter the name in the class located in the src\Measurement folder that will be used for measurements
 51 | -->
 52 | <measurementClassConfFile value="IPC"/>
 53 |  <!--
 54 |  enter the name of the configuration file for the measurement class.. the file must be located in configurationFiles/measurement directory
 55 | -->
 56 | 
 57 | <fitnessClass value="DefaultFitness"/>
 58 |  <!--
 59 | Enter the name of the class located in the src\Fitness folder that will be used for calculating the fitness of individuals
 60 | -->
 61 | <instruction_percentage_clue value="False"/>
 62 |  <!--
 63 |  your initial population will start with a fix number of different instruction types e.g. 50% neon 25% mem and 25% short latency.. Is useful If you can 
 64 |     tell what is the good instruction mix becaue the algorithm will converge more quickly. True/False case-sensitive
 65 | -->
 66 |  <!-- end of general GA inputs -->
 67 |  <!-- End of Register and memory initialization -->
 68 |  <!-- Input/output dir -->
 69 |     
 70 |     <!--end of general GA inputs-->
 71 |     
 72 | 
 73 |     <!--Input/output dir-->
 74 |     <dirToSaveResults
 75 |         value="C:/Users/admin/Desktop/Garuns/ARM_IPC/"      
 76 |     />    <!-- The code sequeneces will be save in ascii format in .txt files in the specified dir. The name format of each file goes like this populationNumber_individualsIdNumber_fitnessValue_measurement1_.... Also a dir which is named
 77 |     after the date/time of the start of the run is created. This dir will contain each population saved in .pkl file and the rand state (also in .pkl format) at each population. This dir can be used as seed dir in case you want to continue an unfinished run. 
 78 |     Also the contents of this dir can be used for parsing results. The parseGeneticResults.py is an example of how to parse the population files and get statistics -->
 79 |   
 80 |     <seedDir
 81 |       value=""
 82 |     />
 83 |      <!--Use the seedDir if you only want to begin algorithm from some specific indivduals instead of random population. In case you don't want to use this just put "". Otherwise point to the dir that contains the pkl files.. look the dirToSaveResults attribute for more details -->
 84 |    
 85 |     
 86 |   
 87 |     <compilationDir 
 88 |       value="C:/Users/admin/Desktop/liClipseWorkspace/GeST/assembly_compilation_ARM/"
 89 |       />
 90 |        <!-- Dir where the compilation code is located .. IMPORTANT the main_original.s must always contain a line #loop_code. At that line
 91 |       the framework will bring in the generated code sequence.. In main_original.s and startup_original.s you can place all the code that you want to be common between each individual e.g. memory and register initialization... 
 92 |       Actually the only thing that will differ among each individual run
 93 |       should be the individual's code sequence which is placed under the "#loop_code" line-->
 94 | 
 95 |     <!--End of Input/output dir-->
 96 | 
 97 | 
 98 |     <run_type
 99 |   value="0" >   
100 |     </run_type>
101 |     <!--Ignore this input. You should have it always at zero.-->
102 |     
103 |   </general_inputs>
104 | 
105 |   <instruction_types> <!--Specify intruction types and how much will be the amount of each type in the loop.. The percentage will be considered only if the instruction_percentage_clue is set to "True"-->
106 |     
107 |     <!-- how much percentage of each kind of instructions type the loop will consist of.. -->
108 |     <instruction_type
109 |       id="shortLat"
110 |       perc="0.40"
111 |     />
112 | 
113 |     <instruction_type
114 |       id="longLat"
115 |       perc="0.02"
116 |     />
117 | 
118 |     <instruction_type
119 |       id="neonVfp"
120 |       perc="0.0"
121 |     />
122 |     
123 |      <instruction_type
124 |       id="floatingPoint"
125 |       perc="0.38"
126 |     />
127 | 
128 |     <instruction_type
129 |       id="mem"
130 |       perc="0.15"
131 |     />
132 | 
133 |     <instruction_type
134 |       id="branch"
135 |       perc="0.05"
136 |     />
137 | 
138 |   
139 |   </instruction_types>
140 | 
141 |   <instructions_operands>
142 |     
143 |      
144 |        <!-- In this section you define all operands that are going to be used by the instructions.. In this section you must define different type of registers e.g. integer registers and float register, branch labels
145 |     immediate values and memory subscripts.. Basically you must define whatever comes after an instruction name and you want to be touched by the evolution process of the algorithm-->
146 |     
147 |     <!--For each operand you must define an id.. the possible values the operand can take.. and the type of operand... 
148 |     the algorithm understands and treats differently 3 types of operands 
149 |     1)registers, 2)constant values(e.g. #4 in LDR x0,[x1,#4]), and 3) immediate values (same thing as constant values)
150 |     The type must be specified in the type attribute ath the operand definition (examples below)
151 |     
152 |     The immediate/constant operand's values can be specified with the min max and stride parameters
153 |         
154 |         <operand
155 |     id="mem_address_subscript"
156 |     min="0"
157 |     max="4092"
158 |     stride="4"
159 |     type="constant"
160 |     toggle="False">
161 |     </operand>
162 |    
163 |    while registers are specified through values parameter e.g.
164 |    
165 |           <operand
166 |     id="simd_register"
167 |     values="v0.4s v1.4s v2.4s v3.4s v4.4s v5.4s v6.4s v7.4s v8.4s v9.4s v10.4s v11.4s"
168 |     type="register"
169 |      toggle="False">
170 |     </operand>
171 |    
172 |     Toggling flag is broken don't use it
173 |     
174 |     -->
175 |     
176 |     
177 |           <operand
178 |     id="simd_register"
179 |     values="v0.4s v1.4s v2.4s v3.4s v4.4s v5.4s v6.4s v7.4s v8.4s v9.4s v10.4s v11.4s"
180 |     type="register"
181 |      toggle="False">
182 |     </operand>
183 |     
184 |     <operand
185 |    id="integer_register"
186 |    values="x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x29 x30"
187 |    type="register"
188 |    toggle="False">
189 |     </operand>
190 |     
191 |      <operand
192 |    id="integer_result_register"
193 |    values="x0"
194 |    type="register"
195 |    toggle="False">
196 |     </operand>
197 |     
198 |      <operand
199 |    id="word_register"
200 |    values="w0 w1 w3 w4 w5 w6 w7 w8 w9 w13 w14 w15 w16 w17 w18 w19 w20 w21 w22 w23 w24 w25 w26 w27 w28 w29 w30"
201 |    type="register"
202 |    toggle="False">
203 |     </operand>
204 | 
205 | 
206 |  <!--  <operand
207 |   id="mul_low"
208 |   values="r0 r1 r4"
209 |   type="register"
210 |   toggle="False"
211 | >
212 |     </operand>
213 | 
214 |     <operand
215 |   id="mul_high"
216 |   values="r5 r8 r9"
217 |   type="register"
218 |   toggle="False"
219 | >
220 |     </operand> -->   
221 | 
222 | 
223 |     <operand
224 |  id="mem_result"
225 |  values="x2" 
226 |  type="register"
227 |  toggle="False"
228 |    >
229 |     </operand>          <!-- dont include this in integer registers to avoid stalls due to memory.. at least for high IPC target, max power and etc -->
230 | 
231 |    <operand
232 |    id="mem_result2"
233 |    values="x3"
234 |    type="register"
235 |    toggle="False"
236 |    >
237 |     </operand>  
238 | 
239 |     <operand
240 |  id="mem_str"
241 |  values="x6"
242 |  type="register"
243 |  toggle="False"
244 |    >
245 |     </operand>
246 | 
247 |    <operand
248 |    id="mem_str2"
249 |    values="x7"
250 |    type="register"
251 |    toggle="False"
252 |    >
253 |     </operand> 
254 | 
255 |     <operand
256 |   id="float_register"
257 |   values="s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 s11 s12"
258 |   type="register"
259 |    toggle="False">
260 |     </operand>
261 |     <operand
262 |     id="double_register"
263 |     values="d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 d10 d11 d12 d13 d14 d15 d16 d17 d18 d19 d20 d21 d22 d23 d24 d25 d26 d27 d28 d29 d30"
264 |     type="register"
265 |      toggle="False">
266 |     </operand>
267 |     
268 |     
269 | 
270 |     <operand
271 |     id="double_mem_res1"
272 |     values="d10"
273 |     type="register"
274 |      toggle="False">
275 |     </operand>
276 | 
277 |     <operand
278 |     id="double_mem_res2"
279 |     values="d11"
280 |     type="register"
281 |      toggle="False">
282 |     </operand>
283 | 
284 |     <operand
285 | id="double_mem_str1"
286 | values="d12"
287 | type="register"
288 |  toggle="False">
289 |     </operand>
290 | 
291 |     <operand
292 | id="double_mem_str2"
293 | values="d13"
294 | type="register"
295 |  toggle="False">
296 |     </operand>
297 | 
298 |     <operand
299 |    id="quad_register"
300 |    values="q1 q2 q3 q4 q5 q6 q7 q8 q9 q10 q11 q12"
301 |    type="register"
302 |     toggle="False">
303 |     </operand>
304 |     
305 | 
306 |     <operand
307 |      id="l1_miss_address_register"
308 |      values="x11"
309 |      type="register"
310 |      toggle="False">
311 |     </operand>
312 | 
313 |     <operand
314 |     id="mem_address_register"
315 |     values="x10"
316 |     type="register"
317 |     toggle="False">
318 |     </operand>
319 | 
320 | 
321 |     <operand
322 |     id="shift_value"
323 |     min="31"
324 |     max="31"
325 |     stride="1"
326 |     type="constant"
327 |     toggle="False">
328 |     </operand>
329 | 
330 | 
331 |     <operand
332 |     id="constant_value"
333 |     min="0"
334 |     max="4092"
335 |     stride="4"
336 |     type="constant"
337 |     toggle="False">
338 |     </operand>
339 | 
340 | 
341 |     <operand
342 |    id="constant_value2"
343 |    min="0"
344 |    max="256"
345 |    stride="8"
346 |    type="constant"
347 |    toggle="False">
348 |     </operand>
349 | 
350 |     <operand
351 |   id="constant_value_vector"
352 |   min="0"
353 |   max="1020"
354 |   stride="4"
355 |   type="constant"
356 |   toggle="False">
357 |     </operand>
358 | 
359 |     <operand
360 |   id="constant_value3"
361 |   min="256"
362 |   max="256"
363 |   stride="8"
364 |   type="constant"
365 |   toggle="False">
366 |     </operand>
367 |     
368 |     
369 |     <operand
370 |   id="constant_value4"
371 |   min="0"
372 |   max="256"
373 |   stride="16"
374 |   type="constant"
375 |   toggle="False">
376 |     </operand>
377 | 
378 |     <operand
379 |   id="branch_label"
380 |   values="dummyLoop"
381 |   min="0"
382 |   max="0"
383 |   stride="1"
384 |   type="branch_label"
385 |   toggle="False">
386 |     </operand>
387 | 
388 |     <!-- min max stride for brach_label are for defining the position of the label in code.. e.g. 0 means imediately after the b instruction -->
389 | 
390 |     <operand
391 |   id="branch_label_increment"
392 |   values=""
393 |     min="0"
394 |    max="4000000000"
395 |    stride="1"
396 |   type="automatically_incremented_operand"
397 |   toggle="False">
398 |     </operand>
399 |     
400 |     
401 |   </instructions_operands>
402 | 
403 |   <instructions>
404 | 
405 |     <!--In this section you will specify the instructions you want the framework to use in the optimization
406 |     process.. -->
407 | 
408 |     <!-- Lets understand how to decalare an instruction by explaining the following example
409 |     
410 |        <instruction
411 |       name="ADD"
412 |       num_of_operands="3"
413 |       type="shortLat"
414 |        operand1="integer_register"
415 |         operand2="integer_register"
416 |        operand3="integer_register"
417 |         format="ADD op1,op2,op3"
418 |       toggle="False">
419 |     </instruction> 
420 |     
421 |      The name attribute is basically the unique indentifier of this instruction, usually you will be fine by just putting the instruction name (like in the example ADD)... 
422 |     The num of operands and type attributes are pretty auto-explainable
423 |     Note that each instruction must belong to an instruction type which was defined in the instruction_type section. As you can see in the example the instruction belongs to shortLatency instruction type
424 |     
425 |     For operand1, operand2 and etc you must specify an operand id that exists in the instructions_operands section.. 
426 |     In the format attribute put the string that represents the syntax of the instruction. op1, op2 and op3 point out to the place where each instruction's operand should be. 
427 |     don't bother with toggle attribute is broken
428 |     -->
429 | 
430 |   
431 |     
432 | 
433 |     <!--   <instruction
434 |       name="ADDEQ"
435 |       num_of_operands="3"
436 |       type="integer"
437 |        operand1="integer_register"
438 |         operand2="integer_register"
439 |        operand3="integer_register">
440 |     </instruction> -->
441 | 
442 |    <!-- <instruction
443 |      name="ADDS_LSLS"
444 |      num_of_operands="4"
445 |      type="shortLat"
446 |       operand1="integer_register"
447 |      operand2="integer_register"
448 |      operand3="integer_register"
449 |     operand4="shift_value"
450 |      format="ADDS op1,op2,op3,LSL #op4"
451 |      toggle="False">
452 |     </instruction> --> 
453 | 
454 |  <!--
455 |    <instruction
456 |       name="NOP"
457 |       num_of_operands="0"
458 |       format="NOP"
459 |       type="miscelaneous"
460 |       toggle="False"
461 |       ></instruction>
462 | 
463 |    <instruction
464 |       name="EMPTY_INS"
465 |       num_of_operands="0"
466 |       format=""
467 |       type="miscelaneous"
468 |       toggle="False"
469 |       ></instruction>
470 | -->
471 | 
472 |  <instruction
473 |       name="NOP"
474 |       num_of_operands="0"
475 |       type="miscelaneous"
476 |       format="NOP"
477 |       toggle="False"
478 |       ></instruction>
479 |       
480 |        <instruction
481 |       name="dummyBranch"
482 |       num_of_operands="0"
483 |       type="branch"
484 |       format="b 4"
485 |       toggle="False"
486 |       ></instruction>
487 | 
488 |    <!-- short int-->
489 |   
490 |   <instruction
491 |       name="ADDS"
492 |       num_of_operands="3"
493 |       type="shortLat"
494 |        operand1="integer_register"
495 |       operand2="integer_register"
496 |      operand3="integer_register"
497 |       format="ADDS op1,op2,op3"
498 |       toggle="False">
499 |     </instruction> 
500 |     
501 |     <instruction
502 |       name="ADD"
503 |       num_of_operands="3"
504 |       type="shortLat"
505 |        operand1="integer_register"
506 |       operand2="integer_register"
507 |      operand3="integer_register"
508 |       format="ADD op1,op2,op3"
509 |       toggle="False">
510 |     </instruction>
511 | 
512 | 
513 |     <instruction
514 |   name="LSL"
515 |   num_of_operands="3"
516 |   type="shortLat"
517 |   format="LSL op1,op2,#op3"
518 |   operand1="integer_register"
519 |    operand2="integer_register"
520 |    operand3="shift_value"
521 |   toggle="False">
522 |     </instruction>
523 | 
524 |     <instruction
525 |  name="ASR"
526 |  num_of_operands="3"
527 |  type="shortLat"
528 |  format="ASR op1,op2,#op3"
529 |  operand1="integer_register"
530 |   operand2="integer_register"
531 |   operand3="shift_value"
532 |  toggle="False">
533 |     </instruction>
534 | 
535 |     <instruction
536 |     name="ROR"
537 |     num_of_operands="3"
538 |     type="shortLat"
539 |     format="ROR op1,op2,#op3"
540 |         operand1="integer_register"
541 |     operand2="integer_register"
542 |     operand3="shift_value"
543 |    toggle="False">
544 |     </instruction>
545 |     
546 |         <instruction
547 |   name="SUB"
548 |   num_of_operands="3"
549 |   type="shortLat"
550 |   operand1="integer_register"
551 |     operand2="integer_register"
552 |    operand3="integer_register"
553 |   format="SUB op1,op2,op3"
554 |   toggle="False">
555 |     </instruction>
556 | 
557 |     <instruction
558 |   name="MOV"
559 |   num_of_operands="2"
560 |   type="shortLat"
561 |   format="MOV op1,op2"
562 | operand1="integer_register"
563 |   operand2="integer_register"
564 |   toggle="False"
565 |       >
566 |     </instruction>
567 |     
568 |     <!-- long int-->
569 |     
570 |      <instruction
571 |       name="MUL"
572 |       num_of_operands="3"
573 |       type="longlat"
574 |       operand1="integer_register"
575 |       operand2="integer_register"
576 |       operand3="integer_register"
577 |         format="MUL op1,op2,op3"
578 |       toggle="False">
579 |     </instruction> 
580 |     
581 |     <!-- memory -->
582 |     
583 |  <instruction
584 |   name="STP"
585 |   num_of_operands="4"
586 |   type="mem"
587 |   format="STP op1,op2,[op3,#op4]"
588 |   operand1="integer_register"
589 |   operand2="integer_register"
590 |   operand3="mem_address_register"
591 |   operand4="constant_value2"
592 |   toggle="False"
593 |       >
594 |     </instruction>
595 | 
596 |  <instruction
597 |   name="STR"
598 |   num_of_operands="3"
599 |   type="mem"
600 |   format="STR op1,[op2,#op3]"
601 |   operand1="integer_register"
602 |   operand2="mem_address_register"
603 |   operand3="constant_value4"
604 |   toggle="False"
605 |       >
606 |     </instruction>
607 |  
608 | 
609 |     <instruction
610 |     name="LDP"
611 |     num_of_operands="4"
612 |     type="mem"
613 |     format="LDP op1,op2,[op3,#op4]"
614 |     operand1="mem_result"
615 |     operand2="mem_result2"
616 |     operand3="mem_address_register"
617 |     operand4="constant_value2"
618 |     toggle="False"
619 |       >
620 |     </instruction>
621 |     
622 |         <instruction
623 |     name="LDR"
624 |     num_of_operands="3"
625 |     type="mem"
626 |     format="LDR op1,[op2,#op3]"
627 |     operand1="integer_register"
628 |     operand2="mem_address_register"
629 |     operand3="constant_value2"
630 |     toggle="False"
631 |       >
632 |     </instruction>
633 |   
634 |     <!-- float point-->
635 |     
636 |         <instruction
637 | name="FCMP"
638 | num_of_operands="2"
639 | type="floatingPoint"
640 | format="FCMP op1,op2"
641 | operand1="double_register"
642 | operand2="double_register"
643 |  toggle="False">
644 |     </instruction>
645 | 
646 |     <instruction
647 | name="FMOV"
648 | num_of_operands="2"
649 | type="floatingPoint"
650 | format="FMOV op1,op2"
651 | operand1="double_register"
652 | operand2="double_register"
653 |  toggle="False">
654 |     </instruction>
655 |     
656 | <instruction
657 | name="FMUL"
658 | num_of_operands="3"
659 | type="floatingPoint"
660 | format="FMUL op1,op2,op3"
661 | operand1="double_register"
662 | operand2="double_register"
663 | operand3="double_register"
664 |  toggle="False">
665 |     </instruction>
666 | 
667 |     <instruction
668 |    name="FADD"
669 |    num_of_operands="3"
670 |    type="floatingPoint"
671 |    format="FADD op1,op2,op3"
672 |    operand1="double_register"
673 |    operand2="double_register"
674 |    operand3="double_register"
675 |     toggle="False">
676 |     </instruction>
677 | 
678 |   <instruction
679 |   name="SCVTF"
680 |     num_of_operands="2"
681 |     type="floatingPoint"
682 |     format="SCVTF op1,op2"
683 |     operand1="double_register"
684 |     operand2="integer_register"
685 |     toggle="False"
686 |       >
687 |   </instruction>
688 |   
689 |     <instruction
690 |   name="FCVTAS"
691 |     num_of_operands="2"
692 |     type="floatingPoint"
693 |     format="FCVTAS op1,op2"
694 |     operand1="integer_register"
695 |     operand2="double_register"
696 |     toggle="False"
697 |       >
698 |   </instruction>
699 | 
700 |     <instruction
701 |      name="FMADD"
702 |      num_of_operands="4"
703 |      type="floatingPoint"
704 |      format="FMADD op1,op2,op3,op4"
705 |      operand1="double_register"
706 |      operand2="double_register"
707 |      operand3="double_register"
708 |      operand4="double_register"
709 |       toggle="False">
710 |     </instruction>
711 | 
712 |     <instruction
713 |   name="FSQRT"
714 |   num_of_operands="2"
715 |   type="floatingPoint"
716 |   format="FSQRT op1,op2"
717 |   operand1="double_register"
718 |   operand2="double_register"
719 |    toggle="False">
720 |     </instruction>
721 |     
722 |         <instruction
723 |   name="FABS"
724 |   num_of_operands="2"
725 |   type="floatingPoint"
726 |   format="FABS op1,op2"
727 |   operand1="double_register"
728 |   operand2="double_register"
729 |    toggle="False">
730 |     </instruction>
731 | 
732 |         <instruction
733 | name="FDIV"
734 | num_of_operands="3"
735 | type="floatingPoint"
736 | format="FDIV op1,op2,op3"
737 | operand1="double_register"
738 | operand2="double_register"
739 | operand3="double_register"
740 |  toggle="False">
741 |     </instruction>
742 | 
743 |     <!-- SIMD   -->
744 | 
745 |         <instruction
746 |   name="FABS_simd"
747 |   num_of_operands="2"
748 |   type="simd"
749 |   format="FABS op1,op2"
750 |   operand1="simd_register"
751 |   operand2="simd_register"
752 |    toggle="False">
753 |     </instruction>
754 | 
755 |     <instruction
756 | name="FRSQRTS_simd"
757 | num_of_operands="3"
758 | type="simd"
759 | format="FRSQRTS op1,op2,op3"
760 | operand1="simd_register"
761 | operand2="simd_register"
762 | operand3="simd_register"
763 |  toggle="False">
764 |     </instruction>
765 |        
766 |     <instruction
767 | name="FDIV_simd"
768 | num_of_operands="3"
769 | type="simd"
770 | format="FDIV op1,op2,op3"
771 | operand1="simd_register"
772 | operand2="simd_register"
773 | operand3="simd_register"
774 |  toggle="False">
775 |     </instruction>
776 |     
777 |            
778 |     <instruction
779 | name="FMLA_simd"
780 | num_of_operands="3"
781 | type="simd"
782 | format="FMLA op1,op2,op3"
783 | operand1="simd_register"
784 | operand2="simd_register"
785 | operand3="simd_register"
786 |  toggle="False">
787 |     </instruction>
788 |     
789 |     
790 |    <instruction
791 | name="FMUL_simd"
792 | num_of_operands="3"
793 | type="simd"
794 | format="FMUL op1,op2,op3"
795 | operand1="simd_register"
796 | operand2="simd_register"
797 | operand3="simd_register"
798 |  toggle="False">
799 |     </instruction>
800 |     
801 |         
802 |                 <instruction
803 | name="FADD_simd"
804 | num_of_operands="3"
805 | type="simd"
806 | format="FADD op1,op2,op3"
807 | operand1="simd_register"
808 | operand2="simd_register"
809 | operand3="simd_register"
810 |  toggle="False">
811 |     </instruction> 
812 |     
813 | 
814 |   </instructions>
815 | 
816 | </GA_inputs>


--------------------------------------------------------------------------------
/configurationFiles/configuration_likwidPowerMeter.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | 
  3 | <!-- 
  4 | Copyright 2019 ARM Ltd. and University of Cyprus
  5 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, 
  6 | including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, 
  7 | and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
  8 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
  9 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 10 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
 11 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 12 | -->
 13 | 
 14 | <GA_inputs>
 15 |   <general_inputs>
 16 | 
 17 |     
 18 |     <!--General GA inputs-->
 19 |     
 20 |     <loopSize value="50"/> <!--The size in instructions of the generated code sequences-->
 21 |     <population_size value="50"/> <!-- The size of each population - generation-->
 22 |     <mutation_rate value="0.02"/> <!-- each instruction will have this probability to be mutated (changed to something else)-->
 23 |     <crossover_type value="1"/>
 24 |     <!--0 for uniform crossover, 1 for one point crossover. This is a good article that explains the crossover typed http://en.wikipedia.org/wiki/Crossover_(genetic_algorithm). I have implemented 
 25 |     only two crossover types the uniform and the 1 point. For generating stress tests I found that 1 point crossover is better since strong instructions sequences have higher chance to survive-->
 26 |     <crossover_rate value="1.0"/>
 27 |     <!--The chance two parent two recombine.. usually is a very high percentage-->
 28 |     <uniform_rate value="0.5"/>
 29 |     <!--Only used when uniform crossover is set... The chance for each instruction to be crossovered-->
 30 |     
 31 |     <populations_to_run value="1000"/>
 32 |     <ellitism value="true"/>
 33 |      <!--
 34 |      true or false. If true the best individual is promoted to the next generation. I think keeping this to "true" is good choice
 35 |     -->
 36 |     <selectionMethod value="0"/>
 37 |      <!--
 38 |      0 for tournament 1 for wheel selection. Only those two are implemented... wheel selection doesn't work really well so I propose tournament. If you want to learn about wheel selection here http://en.wikipedia.org/wiki/Fitness_proportionate_selection
 39 |     -->
 40 |     <tournament_size value="5"/>
 41 |      <!--
 42 |     Only useful with tournament selection. 5 worked well for me but sure feel free to play with this variable more here http://en.wikipedia.org/wiki/Tournament_selection 
 43 |     -->
 44 |     <save_whole_source value="1"/>
 45 |      <!--
 46 |      choose whether to save the whole individual src code or just the loop instructions.. saving the whole source takes ~4X more disk space but is also more convenient 
 47 |     -->
 48 |      <!--
 49 |      when this is 0 to reproduce the src code of an individual copy paste the loop instructions into the template source file (main_original.s) located in compilationDir
 50 |     -->
 51 |     <measurementClass value="MeasurementLikwidPower"/>
 52 |      <!--
 53 |     Enter the name in the class located in the src\Measurement folder that will be used for measurements
 54 |     -->
 55 |     <measurementClassConfFile value="measurementLikwid"/>
 56 |      <!--
 57 |      enter the name of the configuration file for the measurement class.. the file must be located in configurationFiles/measurement directory
 58 |     -->
 59 | 
 60 |     <fitnessClass value="DefaultFitness"/>
 61 |      <!--
 62 |     Enter the name of the class located in the src\Fitness folder that will be used for calculating the fitness of individuals
 63 |     -->
 64 |     <instruction_percentage_clue value="False"/>
 65 |      <!--
 66 |      your initial population will start with a fix number of different instruction types e.g. 50% neon 25% mem and 25% short latency.. Is useful If you can 
 67 |         tell what is the good instruction mix becaue the algorithm will converge more quickly. True/False case-sensitive
 68 |     -->
 69 | <!-- end of general GA inputs -->
 70 | 
 71 |     <!--Input/output dir-->
 72 |     <dirToSaveResults
 73 |         value="C:/Users/admin/Desktop/Garuns/x86_likwid/"      
 74 |     /> 
 75 |       <!-- The code sequeneces will be save in ascii format in .txt files in the specified dir. The name format of each file goes like this populationNumber_individualsIdNumber_fitnessValue_measurement1_.... Also a dir which is named
 76 |     after the date/time of the start of the run is created. This dir will contain each population saved in .pkl file and the rand state (also in .pkl format) at each population. This dir can be used as seed dir in case you want to continue an unfinished run. 
 77 |     Also the contents of this dir can be used for parsing results. The parseGeneticResults.py is an example of how to parse the population files and get statistics -->
 78 |   
 79 |     <seedDir
 80 |       value=""
 81 |     />
 82 |     <!--Use the seedDir if you only want to begin algorithm from some specific indivduals instead of random population. In case you don't want to use this just put "". Otherwise point to the dir that contains the pkl files.. look the dirToSaveResults attribute for more details -->
 83 |    
 84 |     
 85 |   
 86 |     <compilationDir 
 87 |       value="C:/Users/admin/Desktop/liClipseWorkspace/GeST/assembly_compilation_x86_gcc/"
 88 |       />
 89 |          <!-- Dir where the compilation code is located .. IMPORTANT the main_original.s must always contain a line #loop_code. At that line
 90 |       the framework will bring in the generated code sequence.. In main_original.s and startup_original.s you can place all the code that you want to be common between each individual e.g. memory and register initialization... 
 91 |       Actually the only thing that will differ among each individual run
 92 |       should be the individual's code sequence which is placed under the "#loop_code" line-->
 93 | 
 94 |     <!--End of Input/output dir-->
 95 | 
 96 |   
 97 | 
 98 |     <run_type
 99 |   value="0" >
100 |   </run_type>
101 |         <!--Ignore this input. You should have it always at zero.-->
102 |     
103 |     
104 |   </general_inputs>
105 | 
106 |   <instruction_types> <!--Specify intruction types and how much will be the amount of each type in the loop.. The percentage will be considered only if the instruction_percentage_clue is set to "True"-->
107 |     
108 |     <!-- how much percentage of each kind of instructions type the loop will consist of.. -->
109 |     <instruction_type
110 |       id="shortLat"
111 |       perc="0.40"
112 |     />
113 | 
114 |     <instruction_type
115 |       id="longLat"
116 |       perc="0.02"
117 |     />
118 | 
119 |     <instruction_type
120 |       id="neonVfp"
121 |       perc="0.0"
122 |     />
123 |     
124 |      <instruction_type
125 |       id="floatingPoint"
126 |       perc="0.38"
127 |     />
128 | 
129 |     <instruction_type
130 |       id="mem"
131 |       perc="0.15"
132 |     />
133 | 
134 |     <instruction_type
135 |       id="branch"
136 |       perc="0.05"
137 |     />
138 | 
139 |   
140 |   </instruction_types>
141 | 
142 |   <instructions_operands>
143 |     
144 |       
145 |       <!-- In this section you define all operands that are going to be used by the instructions.. In this section you must define different type of registers e.g. integer registers and float register, branch labels
146 |     immediate values and memory subscripts.. Basically you must define whatever comes after an instruction name and you want to be touched by the evolution process of the algorithm-->
147 |     
148 |     <!--For each operand you must define an id.. the possible values the operand can take.. and the type of operand... 
149 |     the algorithm understands and treats differently 3 types of operands 
150 |     1)registers, 2)constant values(e.g. #4 in LDR x0,[x1,#4]), and 3) immediate values (same thing as constant values)
151 |     The type must be specified in the type attribute ath the operand definition (examples below)
152 |     
153 |     The immediate/constant operand's values can be specified with the min max and stride parameters
154 |         
155 |         <operand
156 |     id="mem_address_subscript"
157 |     min="0"
158 |     max="4092"
159 |     stride="4"
160 |     type="constant"
161 |     toggle="False">
162 |     </operand>
163 |    
164 |    while registers are specified through values parameter e.g.
165 |    
166 |           <operand
167 |     id="simd_register"
168 |     values="v0.4s v1.4s v2.4s v3.4s v4.4s v5.4s v6.4s v7.4s v8.4s v9.4s v10.4s v11.4s"
169 |     type="register"
170 |      toggle="False">
171 |     </operand>
172 |    
173 |     Toggling flag is broken don't use it
174 |     
175 |     -->
176 |     
177 |     <operand
178 |    id="integer_register"
179 |    values="%rax %rbx %rdx %rsi %rdi"
180 |    type="register"
181 |    toggle="False">
182 |     </operand>
183 |     
184 |     <operand
185 |    id="sse2_register"
186 |    values="%xmm0 %xmm1 %xmm2 %xmm3 %xmm4 %xmm5 %xmm6 %xmm7 %xmm8 %xmm9 %xmm10 %xmm11 %xmm12 %xmm13 %xmm14 %xmm15"
187 |    type="register"
188 |    toggle="False">
189 |     </operand>
190 |     
191 |      <operand
192 |    id="avx2_register"
193 |    values="%ymm0 %ymm1 %ymm2 %ymm3 %ymm4 %ymm5 %ymm6 %ymm7 %ymm8 %ymm9 %ymm10 %ymm11 %ymm12 %ymm13 %ymm14 %ymm15"
194 |    type="register"
195 |    toggle="False">
196 |     </operand>
197 | 
198 | 
199 |  <operand
200 |     id="imm_value"
201 |     min="0"
202 |     max="2147483647"
203 |     stride="71582785"
204 |     type="constant"
205 |     toggle="False">
206 |     </operand>
207 | 
208 |   <operand
209 |     id="shift_value"
210 |     min="31"
211 |     max="31"
212 |     stride="1"
213 |     type="constant"
214 |     toggle="False">
215 |     </operand>
216 | 
217 |  <operand
218 |     id="mem_offset"
219 |     min="4"
220 |     max="128"
221 |     stride="4"
222 |     type="immediate"
223 |     toggle="False">
224 |     </operand>
225 | 
226 |     
227 |   </instructions_operands>
228 | 
229 |   <instructions>
230 | 
231 |     <!--In this section you will specify the instructions you want the framework to use in the optimization
232 |     process.. -->
233 | 
234 |     <!-- Lets understand how to decalare an instruction by explaining the following example
235 |     
236 |        <instruction
237 |       name="ADD"
238 |       num_of_operands="3"
239 |       type="shortLat"
240 |        operand1="integer_register"
241 |         operand2="integer_register"
242 |        operand3="integer_register"
243 |         format="ADD op1,op2,op3"
244 |       toggle="False">
245 |     </instruction> 
246 |     
247 |      The name attribute is basically the unique indentifier of this instruction, usually you will be fine by just putting the instruction name (like in the example ADD)... 
248 |     The num of operands and type attributes are pretty auto-explainable
249 |     Note that each instruction must belong to an instruction type which was defined in the instruction_type section. As you can see in the example the instruction belongs to shortLatency instruction type
250 |     
251 |     For operand1, operand2 and etc you must specify an operand id that exists in the instructions_operands section.. 
252 |     In the format attribute put the string that represents the syntax of the instruction. op1, op2 and op3 point out to the place where each instruction's operand should be. 
253 |     if you set toggle to True the operands of the instruction that also have the toggle attribute set to "True" will toggle their values every time this instruction is encountered
254 |     -->
255 |     
256 |     <!-- mem instructions -->
257 |     
258 |        <!-- <instruction
259 |       name="ADD_1stMem"
260 |       num_of_operands="2"
261 |       type="intMem"
262 |        operand1="mem_offset"
263 |       operand2="integer_register"
264 |       format="add op1(%rsp),op2"
265 |       toggle="False">
266 |     </instruction> -->  
267 |     
268 |      <!-- <instruction
269 |       name="MUL_1stMem"
270 |       num_of_operands="2"
271 |       type="intMem"
272 |        operand1="mem_offset"
273 |       operand2="integer_register"
274 |       format="imul op1(%rsp),op2"
275 |       toggle="False">
276 |     </instruction>    -->
277 |     
278 |      <!--
279 |     <instruction
280 |       name="MOV_1stMem"
281 |       num_of_operands="2"
282 |       type="intMem"
283 |        operand1="mem_offset"
284 |       operand2="integer_register"
285 |       format="mov op1(%rsp),op2"
286 |       toggle="False">
287 |     </instruction> -->
288 |     
289 |       <instruction
290 |       name="ADD_2ndMem"
291 |       num_of_operands="2"
292 |       type="intMem"
293 |        operand1="integer_register"
294 |       operand2="mem_offset"
295 |       format="add op1,op2(%rsp)"
296 |       toggle="False">
297 |     </instruction>
298 |     
299 |     
300 |       <instruction
301 |       name="AtomicMovSeq1"
302 |       num_of_operands="3"
303 |       type="atomicMemSeq"
304 |       operand1="integer_register"
305 |       operand2="integer_register"
306 |       operand3="integer_register"
307 |       format="mov 0(%rsp),op1\n\tmov 64(%rsp),op2\n\tmov 128(%rsp),op3"
308 |       toggle="False">
309 |     </instruction>
310 |     
311 |     <instruction
312 |       name="AtomicMovSeq2"
313 |       num_of_operands="3"
314 |       type="atomicMemSeq"
315 |       operand1="integer_register"
316 |       operand2="integer_register"
317 |       operand3="integer_register"
318 |       format="mov 192(%rsp),op1\n\tmov 256(%rsp),op2\n\tmov 320(%rsp),op3"
319 |       toggle="False">
320 |     </instruction>
321 |     
322 |     <instruction
323 |       name="AtomicMovSeq3"
324 |       num_of_operands="3"
325 |       type="atomicMemSeq"
326 |       operand1="integer_register"
327 |       operand2="integer_register"
328 |       operand3="integer_register"
329 |       format="mov 384(%rsp),op1\n\tmov 448(%rsp),op2\n\tmov 512(%rsp),op3"
330 |       toggle="False">
331 |     </instruction>
332 |     
333 |     <instruction
334 |       name="MOV_2ndMem"
335 |       num_of_operands="2"
336 |       type="intMem"
337 |        operand1="integer_register"
338 |       operand2="mem_offset"
339 |       format="mov op1,op2(%rsp)"
340 |       toggle="False">
341 |     </instruction>
342 |     
343 | 
344 |     <!-- integer  instructions -->
345 | 
346 |     <instruction
347 |       name="ADD"
348 |       num_of_operands="2"
349 |       type="shortLat"
350 |        operand1="integer_register"
351 |       operand2="integer_register"
352 |       format="add op1,op2"
353 |       toggle="False">
354 |     </instruction>
355 |     
356 |      <instruction
357 |       name="ADD_IM"
358 |       num_of_operands="2"
359 |       type="shortLat"
360 |        operand1="imm_value"
361 |       operand2="integer_register"
362 |       format="add $op1,op2"
363 |       toggle="False">
364 |     </instruction>
365 |     
366 |     <instruction
367 |       name="MUL"
368 |       num_of_operands="2"
369 |       type="longLat"
370 |        operand1="integer_register"
371 |       operand2="integer_register"
372 |       format="imul op1,op2"
373 |       toggle="False">
374 |     </instruction>
375 |     
376 |      <instruction
377 |       name="MUL_IM"
378 |       num_of_operands="2"
379 |       type="longLat"
380 |        operand1="imm_value"
381 |       operand2="integer_register"
382 |       format="imul $op1,op2"
383 |       toggle="False">
384 |     </instruction>
385 | 
386 | 
387 |     <instruction
388 |   name="SHL"
389 |   num_of_operands="2"
390 |   type="shortLat"
391 |   format="shl $op1,op2"
392 |   operand1="shift_value"
393 |    operand2="integer_register"
394 |   toggle="False">
395 |     </instruction>
396 | 
397 |    <instruction
398 |   name="SAR"
399 |   num_of_operands="2"
400 |   type="shortLat"
401 |   format="sar $op1,op2"
402 |   operand1="shift_value"
403 |    operand2="integer_register"
404 |   toggle="False">
405 |     </instruction>
406 | 
407 | 
408 |   <instruction
409 |   name="ROR"
410 |   num_of_operands="2"
411 |   type="shortLat"
412 |   format="ror $op1,op2"
413 |   operand1="shift_value"
414 |    operand2="integer_register"
415 |   toggle="False">
416 |     </instruction>
417 | 
418 | 
419 |     <instruction
420 |   name="MOV"
421 |   num_of_operands="2"
422 |   type="shortLat"
423 |   format="mov op1,op2"
424 | operand1="integer_register"
425 |   operand2="integer_register"
426 |   toggle="False"
427 |       >
428 |     </instruction>
429 |     
430 |     
431 |     <instruction
432 |   name="CMP"
433 |   num_of_operands="2"
434 |   type="shortLat"
435 |   format="cmp op1,op2"
436 | operand1="integer_register"
437 |   operand2="integer_register"
438 |   toggle="False"
439 |       >
440 |     </instruction>
441 |     
442 | <!-- intel floating point --> <!-- commented out because they are obsolete-->
443 | 
444 | 
445 |  <!-- <instruction
446 |    name="FADD"
447 |    num_of_operands="0"
448 |    type="floatingPoint"
449 |    format="faddp"
450 |     toggle="False">
451 |     </instruction>
452 |     
453 |         <instruction
454 |    name="FMUL"
455 |    num_of_operands="0"
456 |    type="floatingPoint"
457 |    format="fmulp"
458 |     toggle="False">
459 |     </instruction>
460 |     -->   
461 |     
462 |     <!-- 
463 |             <instruction
464 |    name="FSQRT"
465 |    num_of_operands="0"
466 |    type="floatingPoint"
467 |    format="fsqrt"
468 |     toggle="False">
469 |     </instruction>
470 |     
471 |         <instruction
472 |    name="FDIV"
473 |    num_of_operands="0"
474 |    type="floatingPoint"
475 |    format="fdivp"
476 |     toggle="False">
477 |     </instruction>
478 | -->
479 | 
480 | <!-- intel avx2-->
481 | 
482 |  <instruction
483 |     name="VADDPD"
484 |     num_of_operands="3"
485 |     type="avx2"
486 |     format="vaddpd op1,op2,op3"
487 |     operand1="avx2_register"
488 |     operand2="avx2_register"
489 |     operand3="avx2_register"
490 |     toggle="False">
491 |     </instruction>
492 |     
493 |     <instruction
494 |     name="VMULPD"
495 |     num_of_operands="3"
496 |     type="avx2"
497 |     format="vmulpd op1,op2,op3"
498 |     operand1="avx2_register"
499 |     operand2="avx2_register"
500 |     operand3="avx2_register"
501 |     toggle="False">
502 |     </instruction>
503 |     
504 |      <instruction
505 |     name="VSUBPD"
506 |     num_of_operands="3"
507 |     type="avx2"
508 |     format="vsubpd op1,op2,op3"
509 |     operand1="avx2_register"
510 |     operand2="avx2_register"
511 |     operand3="avx2_register"
512 |     toggle="False">
513 |     </instruction>
514 |     
515 |          <instruction
516 |     name="VXORPD"
517 |     num_of_operands="3"
518 |     type="avx2"
519 |     format="vxorpd op1,op2,op3"
520 |     operand1="avx2_register"
521 |     operand2="avx2_register"
522 |     operand3="avx2_register"
523 |     toggle="False">
524 |     </instruction>
525 |     
526 |         <instruction
527 |     name="VMAXPD"
528 |     num_of_operands="3"
529 |     type="avx2"
530 |     format="vmaxpd op1,op2,op3"
531 |     operand1="avx2_register"
532 |     operand2="avx2_register"
533 |     operand3="avx2_register"
534 |     toggle="False">
535 |     </instruction>
536 |     
537 |     <!-- intel avx2 storeMem-->
538 | <!-- 
539 |  <instruction
540 |     name="VADDPD_1stMem"
541 |     num_of_operands="3"
542 |     type="avx2"
543 |     format="vaddpd op1(%rsp),op2,op3"
544 |     operand1="mem_offset"
545 |     operand2="avx2_register"
546 |     operand3="avx2_register"
547 |     toggle="False">
548 |     </instruction>
549 |     
550 |     <instruction
551 |     name="VMULPD_1stMem"
552 |     num_of_operands="3"
553 |     type="avx2"
554 |     format="vmulpd op1(%rsp),op2,op3"
555 |     operand1="mem_offset"
556 |     operand2="avx2_register"
557 |     operand3="avx2_register"
558 |     toggle="False">
559 |     </instruction>
560 |     
561 |      <instruction
562 |     name="VSUBPD_1stMem"
563 |     num_of_operands="3"
564 |     type="avx2"
565 |     format="vsubpd op1(%rsp),op2,op3"
566 |     operand1="mem_offset"
567 |     operand2="avx2_register"
568 |     operand3="avx2_register"
569 |     toggle="False">
570 |     </instruction>
571 |     
572 |          <instruction
573 |     name="VXORPD_1stMem"
574 |     num_of_operands="3"
575 |     type="avx2"
576 |     format="vxorpd op1(%rsp),op2,op3"
577 |     operand1="mem_offset"
578 |     operand2="avx2_register"
579 |     operand3="avx2_register"
580 |     toggle="False">
581 |     </instruction>
582 |     
583 |         <instruction
584 |     name="VMAXPD_1stMem"
585 |     num_of_operands="3"
586 |     type="avx2"
587 |     format="vmaxpd op1(%rsp),op2,op3"
588 |     operand1="mem_offset"
589 |     operand2="avx2_register"
590 |     operand3="avx2_register"
591 |     toggle="False">
592 |     </instruction>
593 |     -->
594 |  <!-- <instruction
595 |     name="VPSHUFB"
596 |     num_of_operands="3"
597 |     type="avx2"
598 |     format="vpshufb op1,op2,op3"
599 |     operand1="sse2_register"
600 |     operand2="sse2_register"
601 |     operand3="sse2_register"
602 |     toggle="False">
603 |     </instruction>
604 |     
605 |       <instruction
606 |     name="VPMULUDQ"
607 |     num_of_operands="3"
608 |     type="avx2"
609 |     format="vpmuludq op1,op2,op3"
610 |     operand1="sse2_register"
611 |     operand2="sse2_register"
612 |     operand3="sse2_register"
613 |     toggle="False">
614 |     </instruction>
615 |      -->      
616 |  <!-- <instruction
617 |     name="VPADDW"
618 |     num_of_operands="3"
619 |     type="avx2"
620 |     format="vpaddw op1,op2,op3"
621 |     operand1="sse2_register"
622 |     operand2="sse2_register"
623 |     operand3="sse2_register"
624 |     toggle="False">
625 |     </instruction> -->     
626 |     
627 | 
628 | <!-- intel sse2 --> <!-- commented out because they are obsolete-->
629 | <!-- 
630 |     <instruction
631 |     name="ADDPD"
632 |     num_of_operands="2"
633 |     type="sse2"
634 |     format="addpd op1,op2"
635 |     operand1="sse2_register"
636 |     operand2="sse2_register"
637 |     toggle="False">
638 |     </instruction>
639 |     
640 |         <instruction
641 |     name="ADDSD"
642 |     num_of_operands="2"
643 |     type="sse2"
644 |     format="addsd op1,op2"
645 |     operand1="sse2_register"
646 |     operand2="sse2_register" 
647 |     toggle="False">
648 |     </instruction>
649 | 
650 |       <instruction
651 |     name="MAXSD"
652 |     num_of_operands="2"
653 |     type="sse2"
654 |     format="maxsd op1,op2"
655 |     operand1="sse2_register"
656 |     operand2="sse2_register" 
657 |     toggle="False">
658 |     </instruction>
659 |     
660 |       <instruction
661 |     name="MAXPD"
662 |     num_of_operands="2"
663 |     type="sse2"
664 |     format="maxpd op1,op2"
665 |     operand1="sse2_register"
666 |     operand2="sse2_register" 
667 |     toggle="False">
668 |     </instruction>
669 |     
670 |     <instruction
671 |     name="MINSD"
672 |     num_of_operands="2"
673 |     type="sse2"
674 |     format="minsd op1,op2"
675 |     operand1="sse2_register"
676 |     operand2="sse2_register" 
677 |     toggle="False">
678 |     </instruction>
679 |     
680 |       <instruction
681 |     name="MINPD"
682 |     num_of_operands="2"
683 |     type="sse2"
684 |     format="minpd op1,op2"
685 |     operand1="sse2_register"
686 |     operand2="sse2_register" 
687 |     toggle="False">
688 |     </instruction>
689 |     
690 |         <instruction
691 |     name="MULSD"
692 |     num_of_operands="2"
693 |     type="sse2"
694 |     format="mulsd op1,op2"
695 |     operand1="sse2_register"
696 |     operand2="sse2_register" 
697 |     toggle="False">
698 |     </instruction>
699 |     
700 |       <instruction
701 |     name="MULPD"
702 |     num_of_operands="2"
703 |     type="sse2"
704 |     format="mulpd op1,op2"
705 |     operand1="sse2_register"
706 |     operand2="sse2_register" 
707 |     toggle="False">
708 |     </instruction>
709 |     
710 |             <instruction
711 |     name="SQRTSD"
712 |     num_of_operands="2"
713 |     type="sse2"
714 |     format="sqrtsd op1,op2"
715 |     operand1="sse2_register"
716 |     operand2="sse2_register" 
717 |     toggle="False">
718 |     </instruction>
719 |     
720 |       <instruction
721 |     name="SQRTPD"
722 |     num_of_operands="2"
723 |     type="sse2"
724 |     format="sqrtpd op1,op2"
725 |     operand1="sse2_register"
726 |     operand2="sse2_register" 
727 |     toggle="False">
728 |     </instruction>
729 | 
730 | -->
731 | 
732 | 
733 | 
734 | 
735 |   </instructions>
736 |   </GA_inputs>


--------------------------------------------------------------------------------
/configurationFiles/configuration_x86_IPC.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <!-- 
  3 | Copyright 2019 ARM Ltd. and University of Cyprus
  4 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, 
  5 | including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, 
  6 | and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
  7 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
  8 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
  9 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
 10 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 11 | -->
 12 | 
 13 | <GA_inputs>
 14 |   <general_inputs>
 15 | 
 16 |     
 17 | <!--General GA inputs-->
 18 |     
 19 | <loopSize value="50"/> <!--The size in instructions of the generated code sequences-->
 20 | <population_size value="50"/> <!-- The size of each population - generation-->
 21 | <mutation_rate value="0.02"/> <!-- each instruction will have this probability to be mutated (changed to something else)-->
 22 | <crossover_type value="1"/>
 23 | <!--0 for uniform crossover, 1 for one point crossover. This is a good article that explains the crossover types http://en.wikipedia.org/wiki/Crossover_(genetic_algorithm). I have implemented 
 24 | only two crossover types the uniform and the 1 point. For generating stress tests I found that 1 point crossover is better since strong instructions sequences have higher chance to survive-->
 25 | <crossover_rate value="1.0"/>
 26 | <!--The chance two parent two recombine.. usually is a very high percentage-->
 27 | <uniform_rate value="0.5"/>
 28 | <!--Only used when uniform crossover is set... The chance for each instruction to be crossovered-->
 29 | 
 30 | <populations_to_run value="1000"/>
 31 | <ellitism value="true"/>
 32 |  <!--
 33 |  true or false. If true the best individual is promoted to the next generation. I think keeping this to "true" is good choice
 34 | -->
 35 | <selectionMethod value="0"/>
 36 |  <!--
 37 |  0 for tournament 1 for wheel selection. Only those two are implemented... wheel selection doesn't work really well so I propose tournament. If you want to learn about wheel selection here http://en.wikipedia.org/wiki/Fitness_proportionate_selection
 38 | -->
 39 | <tournament_size value="5"/>
 40 |  <!--
 41 | Only useful with tournament selection. 5 worked well for me but sure feel free to play with this variable more here http://en.wikipedia.org/wiki/Tournament_selection 
 42 | -->
 43 | <save_whole_source value="1"/>
 44 |  <!--
 45 |  choose whether to save the whole individual src code or just the loop instructions.. saving the whole source takes ~4X more disk space but is also more convenient 
 46 | -->
 47 |  <!--
 48 |  when this is 0 to reproduce the src code of an individual copy paste the loop instructions into the template source file (main_original.s) located in compilationDir
 49 | -->
 50 | <measurementClass value="MeasurementIPC"/>
 51 |  <!--
 52 | Enter the name in the class located in the src\Measurement folder that will be used for measurements
 53 | -->
 54 | <measurementClassConfFile value="IPC"/>
 55 |  <!--
 56 |  enter the name of the configuraiton file for the measurement class.. the file must be located in configurationFiles/measurement directory
 57 | -->
 58 | 
 59 | <fitnessClass value="DefaultFitness"/>
 60 |  <!--
 61 | Enter the name of the class located in the src\Fitness folder that will be used for calculating the fitness of individuals
 62 | -->
 63 | <instruction_percentage_clue value="False"/>
 64 |  <!-- your initial population will start with a fix number of different instruction types e.g. 50% neon 25% mem and 25% short latency.. If you know a good instruction mix it may
 65 |      speedup the algorithm convergence. True/False case-sensitive-->
 66 |      
 67 |  <!-- end of general GA inputs -->
 68 |  <!-- End of Register and memory initialization -->
 69 |  <!-- Input/output dir -->
 70 |     
 71 |     <!--end of general GA inputs-->
 72 |     
 73 | 
 74 |     <!--Input/output dir-->
 75 |     <dirToSaveResults
 76 |         value="C:/Users/admin/Desktop/Garuns/x86_IPC/"      
 77 |     /> 
 78 |     <!-- The code sequeneces will be save in ascii format in .txt files in the specified dir. The name format of each file goes like this populationNumber_individualsIdNumber_fitnessValue_measurement1_.... Also a dir which is named
 79 |     after the date/time of the start of the run is created. This dir will contain each population saved in .pkl file and the rand state (also in .pkl format) at each population. This dir can be used as seed dir in case you want to continue an unfinished run. 
 80 |     Also the contents of this dir can be used for parsing results. The parseGeneticResults.py is an example of how to parse the population files and get statistics -->
 81 |     
 82 |     <seedDir
 83 |       value=""
 84 |     />
 85 |      <!--Use the seedDir if you only want to begin algorithm from some specific indivduals instead of random population. In case you don't want to use this just put "". Otherwise point to the dir that contains the pkl files.. look the dirToSaveResults attribute for more details -->
 86 |    
 87 |     
 88 |   
 89 |     <compilationDir 
 90 |       value="C:/Users/admin/Desktop/liClipseWorkspace/GeST/assembly_compilation_x86_gcc/"
 91 |       />
 92 |      <!-- Dir where the compilation code is located .. IMPORTANT the main_original.s must always contain a line #loop_code. At that line
 93 |       the framework will bring in the generated code sequence.. In main_original.s and startup_original.s you can place all the code that you want to be common between each individual e.g. memory and register initialization... 
 94 |       Actually the only thing that will differ among each individual run
 95 |       should be the individual's code sequence which is placed under the "#loop_code" line-->
 96 |       
 97 |     <!--End of Input/output dir-->
 98 | 
 99 |    
100 | 
101 |     <run_type
102 |   value="0" >   
103 |     </run_type>
104 |     <!--Ignore this input. You should have it always at zero.-->
105 |     
106 |   </general_inputs>
107 | 
108 |   <instruction_types> <!--Specify intruction types and how much will be the amount of each type in the loop.. The percentage will be considered only if the instruction_percentage_clue is set to "True"-->
109 |     
110 |     <!-- how much percentage of each kind of instructions type the loop will consist of.. -->
111 |     <instruction_type
112 |       id="shortLat"
113 |       perc="0.40"
114 |     />
115 | 
116 |     <instruction_type
117 |       id="longLat"
118 |       perc="0.02"
119 |     />
120 | 
121 |     <instruction_type
122 |       id="neonVfp"
123 |       perc="0.0"
124 |     />
125 |     
126 |      <instruction_type
127 |       id="floatingPoint"
128 |       perc="0.38"
129 |     />
130 | 
131 |     <instruction_type
132 |       id="mem"
133 |       perc="0.15"
134 |     />
135 | 
136 |     <instruction_type
137 |       id="branch"
138 |       perc="0.05"
139 |     />
140 | 
141 |   
142 |   </instruction_types>
143 | 
144 |   <instructions_operands>
145 |     
146 |     
147 |     <!-- In this section you define all operands that are going to be used by the instructions.. In this section you must define different type of registers e.g. integer registers and float register, branch labels
148 |     immediate values and memory subscripts.. Basically you must define whatever comes after an instruction name and you want to be touched by the evolution process of the algorithm-->
149 |     
150 |     <!--For each operand you must define an id.. the possible values the operand can take.. and the type of operand... 
151 |     the algorithm understands and treats differently 3 types of operands 
152 |     1)registers, 2)constant values(e.g. #4 in LDR x0,[x1,#4]), and 3) immediate values (same thing as constant values)
153 |     The type must be specified in the type attribute ath the operand definition (examples below)
154 |     
155 |     The immediate/constant operand's values can be specified with the min max and stride parameters
156 |         
157 |         <operand
158 |     id="mem_address_subscript"
159 |     min="0"
160 |     max="4092"
161 |     stride="4"
162 |     type="constant"
163 |     toggle="False">
164 |     </operand>
165 |    
166 |    while registers are specified through values parameter e.g.
167 |    
168 |           <operand
169 |     id="simd_register"
170 |     values="v0.4s v1.4s v2.4s v3.4s v4.4s v5.4s v6.4s v7.4s v8.4s v9.4s v10.4s v11.4s"
171 |     type="register"
172 |      toggle="False">
173 |     </operand>
174 |    
175 |     Toggling flag is broken don't use it
176 |     
177 |     -->
178 |     
179 |     <operand
180 |    id="integer_register"
181 |    values="%rax %rbx %rdx %rsi %rdi"
182 |    type="register"
183 |    toggle="False">
184 |     </operand>
185 |     
186 |     <operand
187 |    id="sse2_register"
188 |    values="%xmm0 %xmm1 %xmm2 %xmm3 %xmm4 %xmm5 %xmm6 %xmm7"
189 |    type="register"
190 |    toggle="False">
191 |     </operand>
192 | 
193 | 
194 |  <operand
195 |     id="imm_value"
196 |     min="0"
197 |     max="2147483647"
198 |     stride="71582785"
199 |     type="constant"
200 |     toggle="False">
201 |     </operand>
202 | 
203 |   <operand
204 |     id="shift_value"
205 |     min="31"
206 |     max="31"
207 |     stride="1"
208 |     type="constant"
209 |     toggle="False">
210 |     </operand>
211 | 
212 |  <operand
213 |     id="mem_offset"
214 |     min="4"
215 |     max="128"
216 |     stride="4"
217 |     type="constant"
218 |     toggle="False">
219 |     </operand>
220 | 
221 |     
222 |   </instructions_operands>
223 | 
224 |   <instructions>
225 | 
226 |     <!--In this section you will specify the instructions you want the framework to use in the optimization
227 |     process.. -->
228 | 
229 |     <!-- Lets understand how to decalare an instruction by explaining the following example
230 |     
231 |        <instruction
232 |       name="ADD"
233 |       num_of_operands="3"
234 |       type="shortLat"
235 |        operand1="integer_register"
236 |         operand2="integer_register"
237 |        operand3="integer_register"
238 |         format="ADD op1,op2,op3"
239 |       toggle="False">
240 |     </instruction> 
241 |     
242 |      The name attribute is basically the unique indentifier of this instruction, usually you will be fine by just putting the instruction name (like in the example ADD)... 
243 |     The num of operands and type attributes are pretty auto-explainable
244 |     Note that each instruction must belong to an instruction type which was defined in the instruction_type section. As you can see in the example the instruction belongs to shortLatency instruction type
245 |     
246 |     For operand1, operand2 and etc you must specify an operand id that exists in the instructions_operands section.. 
247 |     In the format attribute put the string that represents the syntax of the instruction. op1, op2 and op3 point out to the place where each instruction's operand should be. 
248 |     don't bother with toggle attribute is broken
249 |     -->
250 | 
251 |     
252 |     <!-- mem instructions -->
253 |     
254 |      <instruction
255 |       name="ADD_1stMem"
256 |       num_of_operands="2"
257 |       type="intMem"
258 |        operand1="mem_offset"
259 |       operand2="integer_register"
260 |       format="add op1(%rsp),op2"
261 |       toggle="False">
262 |     </instruction>
263 |     
264 |       <instruction
265 |       name="ADD_2ndMem"
266 |       num_of_operands="2"
267 |       type="intMem"
268 |        operand1="integer_register"
269 |       operand2="mem_offset"
270 |       format="add op1,op2(%rsp)"
271 |       toggle="False">
272 |     </instruction>
273 |     
274 |     <instruction
275 |       name="MUL_1stMem"
276 |       num_of_operands="2"
277 |       type="intMem"
278 |        operand1="mem_offset"
279 |       operand2="integer_register"
280 |       format="imul op1(%rsp),op2"
281 |       toggle="False">
282 |     </instruction>
283 |     
284 |     <instruction
285 |       name="MOV_1stMem"
286 |       num_of_operands="2"
287 |       type="intMem"
288 |        operand1="mem_offset"
289 |       operand2="integer_register"
290 |       format="mov op1(%rsp),op2"
291 |       toggle="False">
292 |     </instruction>
293 |     
294 |     <instruction
295 |       name="MOV_2ndMem"
296 |       num_of_operands="2"
297 |       type="intMem"
298 |        operand1="integer_register"
299 |       operand2="mem_offset"
300 |       format="mov op1,op2(%rsp)"
301 |       toggle="False">
302 |     </instruction>
303 |     
304 | 
305 |     <!-- integer  instructions -->
306 | 
307 |     <instruction
308 |       name="ADD"
309 |       num_of_operands="2"
310 |       type="shortLat"
311 |        operand1="integer_register"
312 |       operand2="integer_register"
313 |       format="add op1,op2"
314 |       toggle="False">
315 |     </instruction>
316 |     
317 |      <instruction
318 |       name="ADD_IM"
319 |       num_of_operands="2"
320 |       type="shortLat"
321 |        operand1="imm_value"
322 |       operand2="integer_register"
323 |       format="add $op1,op2"
324 |       toggle="False">
325 |     </instruction>
326 |     
327 |     <instruction
328 |       name="MUL"
329 |       num_of_operands="2"
330 |       type="longLat"
331 |        operand1="integer_register"
332 |       operand2="integer_register"
333 |       format="imul op1,op2"
334 |       toggle="False">
335 |     </instruction>
336 |     
337 |      <instruction
338 |       name="MUL_IM"
339 |       num_of_operands="2"
340 |       type="longLat"
341 |        operand1="imm_value"
342 |       operand2="integer_register"
343 |       format="imul $op1,op2"
344 |       toggle="False">
345 |     </instruction>
346 | 
347 | 
348 | 
349 | 
350 |     <instruction
351 |   name="SHL"
352 |   num_of_operands="2"
353 |   type="shortLat"
354 |   format="shl $op1,op2"
355 |   operand1="shift_value"
356 |    operand2="integer_register"
357 |   toggle="False">
358 |     </instruction>
359 | 
360 |    <instruction
361 |   name="SAR"
362 |   num_of_operands="2"
363 |   type="shortLat"
364 |   format="sar $op1,op2"
365 |   operand1="shift_value"
366 |    operand2="integer_register"
367 |   toggle="False">
368 |     </instruction>
369 | 
370 | 
371 |   <instruction
372 |   name="ROR"
373 |   num_of_operands="2"
374 |   type="shortLat"
375 |   format="ror $op1,op2"
376 |   operand1="shift_value"
377 |    operand2="integer_register"
378 |   toggle="False">
379 |     </instruction>
380 | 
381 | 
382 |     <instruction
383 |   name="MOV"
384 |   num_of_operands="2"
385 |   type="shortLat"
386 |   format="mov op1,op2"
387 | operand1="integer_register"
388 |   operand2="integer_register"
389 |   toggle="False"
390 |       >
391 |     </instruction>
392 |     
393 |     
394 |     <instruction
395 |   name="CMP"
396 |   num_of_operands="2"
397 |   type="shortLat"
398 |   format="cmp op1,op2"
399 | operand1="integer_register"
400 |   operand2="integer_register"
401 |   toggle="False"
402 |       >
403 |     </instruction>
404 |     
405 | <!-- intel floating point -->
406 | 
407 | 
408 |     <instruction
409 |    name="FADD"
410 |    num_of_operands="0"
411 |    type="floatingPoint"
412 |    format="faddp"
413 |     toggle="False">
414 |     </instruction>
415 |     
416 |         <instruction
417 |    name="FSQRT"
418 |    num_of_operands="0"
419 |    type="floatingPoint"
420 |    format="fsqrt"
421 |     toggle="False">
422 |     </instruction>
423 |     
424 |         <instruction
425 |    name="FMUL"
426 |    num_of_operands="0"
427 |    type="floatingPoint"
428 |    format="fmulp"
429 |     toggle="False">
430 |     </instruction>
431 |     
432 |         <instruction
433 |    name="FDOV"
434 |    num_of_operands="0"
435 |    type="floatingPoint"
436 |    format="fdivp"
437 |     toggle="False">
438 |     </instruction>
439 | 
440 | <!-- intel simd -->
441 | 
442 |     <instruction
443 |     name="ADDPD"
444 |     num_of_operands="2"
445 |     type="sse2"
446 |     format="addpd op1,op2"
447 |     operand1="sse2_register"
448 |     operand2="sse2_register"
449 |     toggle="False">
450 |     </instruction>
451 |     
452 |         <instruction
453 |     name="ADDSD"
454 |     num_of_operands="2"
455 |     type="sse2"
456 |     format="addsd op1,op2"
457 |     operand1="sse2_register"
458 |     operand2="sse2_register" 
459 |     toggle="False">
460 |     </instruction>
461 | 
462 |       <instruction
463 |     name="MAXSD"
464 |     num_of_operands="2"
465 |     type="sse2"
466 |     format="maxsd op1,op2"
467 |     operand1="sse2_register"
468 |     operand2="sse2_register" 
469 |     toggle="False">
470 |     </instruction>
471 |     
472 |       <instruction
473 |     name="MAXPD"
474 |     num_of_operands="2"
475 |     type="sse2"
476 |     format="maxpd op1,op2"
477 |     operand1="sse2_register"
478 |     operand2="sse2_register" 
479 |     toggle="False">
480 |     </instruction>
481 |     
482 |     <instruction
483 |     name="MINSD"
484 |     num_of_operands="2"
485 |     type="sse2"
486 |     format="minsd op1,op2"
487 |     operand1="sse2_register"
488 |     operand2="sse2_register" 
489 |     toggle="False">
490 |     </instruction>
491 |     
492 |       <instruction
493 |     name="MINPD"
494 |     num_of_operands="2"
495 |     type="sse2"
496 |     format="minpd op1,op2"
497 |     operand1="sse2_register"
498 |     operand2="sse2_register" 
499 |     toggle="False">
500 |     </instruction>
501 |     
502 |         <instruction
503 |     name="MULSD"
504 |     num_of_operands="2"
505 |     type="sse2"
506 |     format="mulsd op1,op2"
507 |     operand1="sse2_register"
508 |     operand2="sse2_register" 
509 |     toggle="False">
510 |     </instruction>
511 |     
512 |       <instruction
513 |     name="MULPD"
514 |     num_of_operands="2"
515 |     type="sse2"
516 |     format="mulpd op1,op2"
517 |     operand1="sse2_register"
518 |     operand2="sse2_register" 
519 |     toggle="False">
520 |     </instruction>
521 |     
522 |             <instruction
523 |     name="SQRTSD"
524 |     num_of_operands="2"
525 |     type="sse2"
526 |     format="sqrtsd op1,op2"
527 |     operand1="sse2_register"
528 |     operand2="sse2_register" 
529 |     toggle="False">
530 |     </instruction>
531 |     
532 |       <instruction
533 |     name="SQRTPD"
534 |     num_of_operands="2"
535 |     type="sse2"
536 |     format="sqrtpd op1,op2"
537 |     operand1="sse2_register"
538 |     operand2="sse2_register" 
539 |     toggle="False">
540 |     </instruction>
541 | 
542 | 
543 | 
544 | 
545 |   </instructions>
546 |   </GA_inputs>


--------------------------------------------------------------------------------
/configurationFiles/measurement/IPC.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | 
 3 | <!-- 
 4 | Copyright 2019 ARM Ltd. and University of Cyprus
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, 
 6 | including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, 
 7 | and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 8 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 9 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
10 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
11 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
12 | -->
13 | 
14 | <inputs>
15 | 
16 |     <targetRunDir 
17 |         value="/root/GA/"
18 |     /> <!-- Dir which holds temporary files on the target device -->
19 |     
20 |      <targetHostname 
21 |         value="127.0.0.1"
22 |     /> <!-- hostname for ssh purposes -->
23 |     
24 |     <targetSSHusername 
25 |         value="root"
26 |     /> <!-- ssh username-->
27 |     
28 |       <targetSSHpassword
29 |         value="root"
30 |     /> <!-- ssh password-->
31 |     
32 |     <!-- space separated -->
33 |      <coresToUse
34 |     value='0'
35 |     />
36 | 
37 | 
38 |    <time_to_measure value="1" />
39 |     
40 | 
41 | </inputs>


--------------------------------------------------------------------------------
/configurationFiles/measurement/measurementLikwid.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | 
 3 | <!-- 
 4 | Copyright 2019 ARM Ltd. and University of Cyprus
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, 
 6 | including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, 
 7 | and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 8 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 9 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
10 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
11 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
12 | -->
13 | 
14 | <inputs>
15 | 
16 |       <targetRunDir 
17 |         value="/root/GA"
18 |     /> <!-- Dir which holds temporary files on the target device -->
19 |     
20 |      <targetHostname 
21 |         value="127.0.0.1"
22 |     /> <!-- hostname for ssh purposes -->
23 |     
24 |     <targetSSHusername 
25 |         value="root"
26 |     /> <!-- ssh username-->
27 |     
28 |       <targetSSHpassword
29 |         value="root"
30 |     /> <!-- ssh password-->
31 |     
32 |     <!-- space separated -->
33 |      <coresToUse
34 |     value='0 1'
35 |     />
36 | 
37 | 
38 |    <time_to_measure value="5" />
39 |        
40 |     
41 | 
42 | </inputs>


--------------------------------------------------------------------------------
/src/Algorithm.py:
--------------------------------------------------------------------------------
  1 | '''
  2 | Copyright 2019 ARM Ltd. and University of Cyprus
  3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, 
  4 | including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, 
  5 | and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
  6 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
  7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
  8 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
  9 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 10 | '''
 11 | 
 12 | import subprocess
 13 | from xml.dom import minidom
 14 | from Instruction import Instruction
 15 | from Operand import Operand
 16 | from Population import Population
 17 | from Individual import Individual
 18 | import math
 19 | import fileinput
 20 | from random import Random
 21 | import os
 22 | import shutil
 23 | import sys
 24 | from threading import Timer
 25 | from threading import Thread
 26 | import time
 27 | import pickle;
 28 | import re;
 29 | import atexit;
 30 | import datetime;
 31 | from paramiko import SSHClient, client
 32 | import paramiko
 33 | import socket
 34 | import platform
 35 | import visa
 36 | from statistics import stdev
 37 | from multiprocessing.pool import ThreadPool
 38 | from multiprocessing import  TimeoutError
 39 | import importlib
 40 | 
 41 | #import serial;
 42 | 
 43 | class Algorithm(object):
 44 | 
 45 | 
 46 |     UNIFORM_CROSSOVER="0"
 47 |     ONEPOINT_CROSSOVER="1"
 48 |     WHEEL_SELECTION="1";
 49 |     TOURNAMENT_SELECTION="0";
 50 |     
 51 |     
 52 |     def __init__(self,configurationFile,rand=Random()): #reads configuration file and initializes the first population        
 53 |         '''general initialization'''
 54 |         self.general_initialization(configurationFile, rand)
 55 |         '''specific initializations'''
 56 |         self.__instructions_operands_init__()
 57 |         print("End of  inputs\n");
 58 |             
 59 |     def general_initialization(self,configurationFile,rand):
 60 |         '''general algorithm and run parameters'''
 61 |         self.xmldoc = minidom.parse(configurationFile)
 62 |         self.intitializeAlgorithmAndRunParameters(configurationFile, rand)
 63 |         '''create results and saved state directories'''
 64 |         self.setupDirs(configurationFile) 
 65 |         '''print general and run parameters'''
 66 |         self.printGeneralInputs();
 67 |         
 68 |         
 69 |     def intitializeAlgorithmAndRunParameters(self,configurationFile,rand):    
 70 |         
 71 |         ##genetic algorithm parameters
 72 |         self.populationSize = self.xmldoc.getElementsByTagName('population_size')[0].attributes['value'].value;  
 73 |         self.mutationRate = self.xmldoc.getElementsByTagName('mutation_rate')[0].attributes['value'].value; 
 74 |         self.crossoverType = self.xmldoc.getElementsByTagName('crossover_type')[0].attributes['value'].value; 
 75 |         self.crossoverRate = self.xmldoc.getElementsByTagName('crossover_rate')[0].attributes['value'].value;
 76 |         self.uniformRate = self.xmldoc.getElementsByTagName('uniform_rate')[0].attributes['value'].value;
 77 |         self.ellitism = self.xmldoc.getElementsByTagName('ellitism')[0].attributes['value'].value;
 78 |         self.selectionMethod=self.xmldoc.getElementsByTagName('selectionMethod')[0].attributes['value'].value;#0 wheel,1 tournament
 79 |         self.tournamentSize = self.xmldoc.getElementsByTagName('tournament_size')[0].attributes['value'].value;  
 80 |         self.populationsToRun=  int(self.xmldoc.getElementsByTagName('populations_to_run')[0].attributes['value'].value);
 81 |       
 82 |         
 83 |         ##compilation and measurement parameters
 84 |         self.fitnessClassName = self.xmldoc.getElementsByTagName('fitnessClass')[0].attributes['value'].value; 
 85 |         
 86 |         module= importlib.import_module("Fitness."+self.fitnessClassName)
 87 |         self.fitnessClass = getattr(module,self.fitnessClassName) 
 88 |         self.fitness = self.fitnessClass()
 89 |          
 90 |         self.measurementClassName = self.xmldoc.getElementsByTagName('measurementClass')[0].attributes['value'].value; 
 91 |         self.measurementClassConfFile = self.xmldoc.getElementsByTagName('measurementClassConfFile')[0].attributes['value'].value;
 92 |         
 93 |                 
 94 |         module= importlib.import_module("Measurement."+self.measurementClassName)
 95 |         self.measurementClass = getattr(module,self.measurementClassName) 
 96 |         if self.measurementClassConfFile[-4:]!=".xml":
 97 |             self.measurementClassConfFile=self.measurementClassConfFile+".xml"
 98 |         self.measurement=self.measurementClass("./configurationFiles/measurement/"+self.measurementClassConfFile)
 99 |         self.measurement.init()   
100 |         
101 |         self.dirToSaveResults = self.xmldoc.getElementsByTagName('dirToSaveResults')[0].attributes['value'].value;
102 |         self.seedDir=self.xmldoc.getElementsByTagName('seedDir')[0].attributes['value'].value;  
103 |         self.compilationDir = self.xmldoc.getElementsByTagName('compilationDir')[0].attributes['value'].value;
104 |         
105 |         ##make sure that dirs end with /
106 |         self.dirToSaveResults=self.__fixDirEnd__(self.dirToSaveResults)
107 |         self.seedDir=self.__fixDirEnd__(self.seedDir)
108 |         self.compilationDir=self.__fixDirEnd__(self.compilationDir)
109 |                      
110 |         ##some other variable initialization
111 |         
112 |         try:
113 |             self.saveWholeSource=self.xmldoc.getElementsByTagName('save_whole_source')[0].attributes['value'].value;  
114 |         except:
115 |             self.saveWholeSource=1
116 |         
117 |         self.population=Population();
118 |         self.rand=rand;
119 |         self.populationsExamined=1;
120 |         self.bestIndividualUntilNow=None;
121 |         self.waitCounter=0;
122 |         self.populationsTested=0  
123 |     
124 |     def __fixDirEnd__(self,dir):
125 |         if dir=="":
126 |             return dir
127 |         if dir[-1:]!="/":
128 |             dir=dir+"/"
129 |         return dir
130 |     
131 |     def setupDirs(self,configurationFile):
132 |         '''create the results dirs'''
133 |         if(not os.path.exists(self.dirToSaveResults)):
134 |             os.mkdir(self.dirToSaveResults);
135 |         self.timeStart=datetime.datetime.now().strftime("%y-%m-%d-%H-%M"); 
136 |         self.savedStateDir=self.dirToSaveResults+self.timeStart+"/"
137 |         if(not os.path.exists(self.savedStateDir)):
138 |             os.mkdir(self.savedStateDir);#create a dir in results dir named after start time that will be used to save state like population and rand state
139 |         atexit.register(self.saveRandstate); #register a function which will save rand state at exit
140 |         
141 |         ''' save configuration src in the results dir '''
142 |         if os.path.exists(self.savedStateDir+"configuration.xml"):
143 |             os.remove(self.savedStateDir+"configuration.xml");
144 |         shutil.copy(configurationFile,self.savedStateDir+"configuration.xml" )
145 |         
146 |         if os.path.exists(self.savedStateDir+"src"):
147 |             shutil.rmtree(self.savedStateDir+"src", ignore_errors=True)  
148 |         shutil.copytree("./src",self.savedStateDir+"src" )
149 |         
150 |         ''' save measurement configuration '''
151 |         if os.path.exists(self.savedStateDir+"measurement.xml"):
152 |             os.remove(self.savedStateDir+"measurement.xml", ignore_errors=True)  
153 |         shutil.copy("./configurationFiles/measurement/"+self.measurementClassConfFile,self.savedStateDir+"measurement.xml")
154 |         
155 |         '''save assembly compilation in the results dir'''
156 |         if os.path.exists(self.savedStateDir+"assembly_compilation"):
157 |             shutil.rmtree(self.savedStateDir+"assembly_compilation", ignore_errors=True)  
158 |         shutil.copytree(self.compilationDir,self.savedStateDir+"assembly_compilation" )
159 |         if os.path.exists(self.savedStateDir+"assembly_compilation/main.s"):
160 |             os.remove(self.savedStateDir+"assembly_compilation/main.s")#remove this because they belong to previous run and this can get confusing
161 |         self.compilationDir=self.savedStateDir+"assembly_compilation/"
162 |         print("New compilationDir is "+self.compilationDir)
163 |         
164 |         
165 |     def __instructions_operands_init__(self):
166 |         self.loopSize = self.xmldoc.getElementsByTagName('loopSize')[0].attributes['value'].value;  
167 |         print ("loop Size: " + self.loopSize);
168 |         
169 |         self.percentage_clue=self.xmldoc.getElementsByTagName('instruction_percentage_clue')[0].attributes['value'].value;      
170 |         print("Percentage clue? :"+self.percentage_clue);
171 |         self.instruction_types={};#a dictionary of instruction type and the amount of each instruction in loop.. Note useful only when percentage clue is True
172 |         self.instructions={}; #a dictionay that has for keeps an array of instructions for every instruction type
173 |         self.allInstructionArray=[]; #An array which hold all instructions
174 |         self.operands={};
175 |         self.toggleInstructionsList={};
176 |         
177 |         itemList = self.xmldoc.getElementsByTagName("instruction_type");
178 |         for instruction_type in itemList:
179 |             name=instruction_type.attributes["id"].value;
180 |             perc= instruction_type.attributes["perc"].value;
181 |             self.instruction_types[name]= int (float(perc) * float(self.loopSize)); '''calculate how many of these instructions will be in the loop'''
182 |         if(self.percentage_clue=="True"):
183 |             print("amount per instruction type in the loop:")
184 |             print (self.instruction_types);
185 |             sum=0;
186 |             for value in list(self.instruction_types.values()):
187 |                 sum+=value;
188 |             self.loopSize=sum;
189 |             print("actual loop size is "+str(self.loopSize));
190 |         
191 |         itemList = self.xmldoc.getElementsByTagName("operand");
192 |         print("Available operands\n")
193 |         for operandDesc in itemList:  
194 |             ins_type=operandDesc.attributes["type"].value;
195 |             if (ins_type=="immediate" or ins_type=="constant" or ins_type=="automatically_incremented_operand"):
196 |                 anOperand = Operand(id=operandDesc.attributes["id"].value,type=operandDesc.attributes["type"].value,values=[],min=operandDesc.attributes["min"].value,max=operandDesc.attributes["max"].value,stride=operandDesc.attributes["stride"].value,toggleable=operandDesc.attributes["toggle"].value);        
197 |             #elif ins_type=="branch_label":
198 |                 #  anOperand = BranchLabel(id=operandDesc.attributes["id"].value,ins_type=operandDesc.attributes["type"].value,values=operandDesc.attributes["values"].value.split(),min=operandDesc.attributes["min"].value,max=operandDesc.attributes["max"].value,stride=operandDesc.attributes["stride"].value,toggleable=operandDesc.attributes["toggle"].value);
199 |             else:
200 |                 anOperand = Operand(id=operandDesc.attributes["id"].value,type=operandDesc.attributes["type"].value,values=operandDesc.attributes["values"].value.split(),toggleable=operandDesc.attributes["toggle"].value);
201 |            
202 |             print("id "+anOperand.id.__str__());
203 |             print ("values ");
204 |             print(anOperand.values);
205 |             print("max "+ anOperand.max.__str__())
206 |             print ("min " + anOperand.min.__str__())
207 |             print("stride "+anOperand.stride.__str__()+"\n")
208 |             self.operands[anOperand.id] = anOperand; 
209 |         print("End of available operands\n")
210 |        
211 |         
212 |         itemList = self.xmldoc.getElementsByTagName("instruction");
213 |         print("Available instructions\n")
214 |         for instructionDesc in itemList:
215 |             name=instructionDesc.attributes["name"].value;
216 |             ins_type=instructionDesc.attributes["type"].value;
217 |             numOfOperands=instructionDesc.attributes["num_of_operands"].value;
218 |             if "format" in instructionDesc.attributes:
219 |                 anInstruction = Instruction(name,ins_type,numOfOperands,format=instructionDesc.attributes["format"].value,toggleable=instructionDesc.attributes["toggle"].value);
220 |             else:
221 |                 print("Instruction "+name+"doesnt have format specified.. All instructions must have format... Exitting");
222 |                 sys.exit();
223 |                 #anInstruction = Instruction(name,ins_type,numOfOperands,toggleable=instructionDesc.attributes["toggle"].value);
224 |             
225 |             if(instructionDesc.attributes["toggle"].value=="True"):
226 |                 self.toggleInstructionsList[instructionDesc.attributes["name"].value]=1;
227 |             
228 |             operands=[];#TODO fix this source of bugs..  It's irritating when the num of operands does not match the operands specified in the xml file. and in general is stupid to how the operands specified and the number of operands at the same time.. this redundancy leads to bugs
229 |             for i in range(1,int(anInstruction.numOfOperands)+1):
230 |                 operands.append(self.operands[(instructionDesc.attributes["operand"+i.__str__()].value)].copy());
231 |             anInstruction.setOperands(operands);
232 |             print(anInstruction); ##for debugging
233 |             self.instructions.setdefault(anInstruction.ins_type,[]).append(anInstruction);
234 |         #print (self.instructions);   
235 |         print("End of available instructions\n");
236 |         
237 |         for array in list(self.instructions.values()):
238 |             for ins in array:
239 |                 self.allInstructionArray.append(ins);
240 |         print("register initialization"); 
241 |         #print(self.registerInitStr);
242 |         #sys.exit()
243 |        
244 |         
245 |     def printGeneralInputs(self):
246 |         print("Debug Inputs");
247 |         print ("Population size: " +self.populationSize);
248 |         print ("Mutation Rate: "+self.mutationRate);
249 |         print ("Crossover Rate: "+self.crossoverRate);
250 |         if(self.crossoverType==Algorithm.ONEPOINT_CROSSOVER):
251 |             print("Crossover Type: one point crossover")
252 |         elif(self.crossoverType==Algorithm.UNIFORM_CROSSOVER):
253 |             print("Crossover Type: uniform crossover")
254 |             print ("Uniform Rate: "+self.uniformRate);
255 |         print ("Ellitism: "+self.ellitism);
256 |         if(self.selectionMethod==Algorithm.TOURNAMENT_SELECTION):
257 |             print("Selection Method: Tournament")
258 |             print ("Tournament selection size: "+self.tournamentSize);
259 |         elif(self.selectionMethod==Algorithm.WHEEL_SELECTION):
260 |             print("Selection Method: Wheel Selection")
261 |         #print ("Termination Conditions are: ");
262 |         #print("If for "+self.populationsToRun+" populations there is no more than "+self.fitnessThreshold+" improvement stop")
263 |         print ("ResultsDir: "+self.dirToSaveResults);
264 |         print ("compilationDir: "+self.compilationDir);
265 |         
266 |     
267 |     @staticmethod
268 |     def returnRunType(configurationFile):
269 |         xmldoc = minidom.parse(configurationFile)
270 |         run_type = xmldoc.getElementsByTagName('run_type')[0].attributes['value'].value;
271 |         if(run_type==Algorithm.PROFILE_RUN):
272 |             return Algorithm.PROFILE_RUN;
273 |         else:
274 |             return Algorithm.INSTRUCTION_RUN 
275 |         
276 |     def saveRandstate(self,postfix=""):
277 |         output=open(self.savedStateDir +"rand_state"+postfix+".pkl","wb");
278 |         pickle.dump(self.rand.getstate(),output);
279 |         output.close();
280 |         
281 |     def loadRandstate(self):
282 |         latest=1;
283 |         if(not os.path.exists(self.seedDir+"rand_state.pkl")):
284 |             for root, dirs, filenames in os.walk(self.seedDir):
285 |                 for f in filenames:
286 |                     if("rand_state" in f):
287 |                         num=int(f.replace("rand_state","").replace(".pkl",""));
288 |                         if(num>latest):
289 |                             latest=num;
290 |             stateToLoad="rand_state"+str(latest)+".pkl";
291 |             input=open(self.seedDir+stateToLoad,"rb");
292 |             self.rand.setstate(pickle.load(input));
293 |             input.close();
294 |         else:
295 |             input=open(self.seedDir+"rand_state.pkl","rb");
296 |             self.rand.setstate(pickle.load(input));
297 |             input.close();
298 |         
299 |     '''def __initializeRegisterValues__ (self):#DEPRECATED DON"T USE THIS ANYMORE AS IT MAY LEAD TO BUGS ##remember this functions expects a clean original copy of main.s 
300 |         for line in fileinput.input(self.compilationDir+"/main.s", inplace=1): #TODO keep in mind that it works with and without /
301 |             print(line,end="");
302 |             if "reg init" in line:
303 |                 print(self.registerInitStr);
304 |         fileinput.close();
305 |     
306 |     def __initializeMemory__ (self,core=1): #DEPRECATED DON"T USE THIS ANYMORE AS IT MAY LEAD TO BUGS  ##remember this functions expects a clean original copy of main.s
307 |         for line in fileinput.input(self.compilationDir+"/startup.s", inplace=1):
308 |             if "MemoryInit"+str(core) in line:
309 |                 print (line,end="");
310 |                 print(self.memoryInitArray[core-1]);
311 |             else:
312 |                 print(line,end="");
313 |         fileinput.close();'''
314 |         
315 |     def createInitialPopulation (self):
316 |         individuals=[];
317 |         if self.seedDir == "": #random initialization
318 |             for i in range(int(self.populationSize)):
319 |                 individuals.append(self.__randomlyCreateIndividual__());
320 |             self.population=Population(individuals);
321 |         else: #initial population based on existing individuals.. Useful for continuing runs that where stopped              
322 |             newerPop=0; ##find which is the newest population      
323 |             for root, dirs, filenames in os.walk(self.seedDir):
324 |                 for f in filenames:
325 |                     if((".pkl" in f) and ("rand" not in f)):
326 |                         tokens=re.split('[_.]',f);                
327 |                         popNum=int(tokens[0]);
328 |                         if (popNum>newerPop):
329 |                             newerPop=popNum;
330 |                 input = open(self.seedDir+str(newerPop)+'.pkl',mode="rb"); 
331 |                 self.population=Population.unpickle(input);
332 |                 input.close();
333 | 
334 |             maxId=0;##track the maxId
335 |             for indiv in self.population.individuals:
336 |                 if(indiv.myId>maxId):
337 |                     maxId=indiv.myId;
338 |             
339 |             Individual.id=maxId; #the new indiv will start from maxId
340 |             self.bestIndividualUntilNow=self.population.getFittest(); #set the best individual seen until now
341 |             self.loopSize=self.bestIndividualUntilNow.getInstructions().__len__(); #ensure that loop Size is correct
342 |             self.populationsExamined=newerPop+1;#population will start from the newer population
343 |             self.loadRandstate(); #load the previous rand state before evolving pop
344 |             self.evolvePopulation(); #immediately evolve population
345 |             
346 |         
347 |         
348 |         return;
349 |   
350 |     def measurePopulation (self):
351 |         for individual in self.population.individuals:
352 |             ##NOTE Due to fluctuations in measurements is desirable to measure the best individual again
353 |             while True:  #measure until measurement succesful... 
354 |                 try:
355 |                     measurements=self.__measureIndividual__(individual);
356 |                     measurement=measurements[0];                  
357 |                     measurement_str="%.6f" % float(measurement);        
358 |                     break;
359 |                 except (ValueError,IOError):
360 |                     continue;
361 |                 
362 |             individual.setMeasurementsVector(measurements);
363 |             fitnessArray=self.fitness.getFitness(individual)
364 |             fitnessValue=fitnessArray[0]
365 |             individual.setFitness(fitnessValue)
366 |             
367 |             measurementStr=""
368 |             
369 |             for measurement in fitnessArray:
370 |                 measurement_str=("%.6f" % float(measurement)).replace(".","DOT").strip()+"_"
371 |                 measurementStr=measurementStr+measurement_str
372 |             
373 |             if int(self.saveWholeSource)==1:
374 |                 fpath=""
375 |                 if(individual.belongsToInitialSeed()): 
376 |                     fpath=self.dirToSaveResults+str(individual.generation)+"_"+str(individual.myId)+"_"+measurementStr+"0_0" +".txt"
377 |                 else:                
378 |                     fpath=self.dirToSaveResults+str(individual.generation)+"_"+str(individual.myId)+"_"+measurementStr+str(individual.parents[0].myId)+"_"+str(individual.parents[1].myId) +".txt"
379 |                 shutil.copy(self.compilationDir+"/main.s",fpath)
380 |             else:
381 |                 if(individual.belongsToInitialSeed()):
382 |                     f = open(self.dirToSaveResults+str(individual.generation)+"_"+str(individual.myId)+"_"+measurementStr+"0_0" +".txt",mode="w")  
383 |                 else:
384 |                     f = open(self.dirToSaveResults+str(individual.generation)+"_"+str(individual.myId)+"_"+measurementStr+str(individual.parents[0].myId)+"_"+str(individual.parents[1].myId) +".txt",mode="w")
385 |                 f.write(individual.__str__());
386 |                 f.close();
387 |             
388 |             
389 |             individual.clearParents();#TODO this is just a cheap hack I do for now in order to avoid the recursive grow in length of .pkl files. This is only okay given that I don't actually need anymore that parents.. fon now is okay  
390 |         ##save a file describing the population so it can be loaded later. useful in case of you want to start a run based on the state of previous runs
391 |         output = open(self.savedStateDir+str(self.populationsExamined)+'.pkl','wb');
392 |         self.population.pickle(output);
393 |         output.close();
394 |         
395 |         ##also save the rand_state
396 |         self.saveRandstate(postfix=str(self.populationsExamined));
397 |         self.populationsExamined=self.populationsExamined+1;
398 |         self.populationsTested=self.populationsTested+1
399 |          
400 |     def __measureIndividual__(self,individual):
401 |             #####before each individual bring back the original copy of main and startup    
402 |             self.__bring_back_code_template__();
403 |             ####initialize register values in main.s
404 |             #self.__initializeRegisterValues__();
405 |             ####dump memory initialization in startup.s for each core
406 |             #for core in range(1,int(int(self.cores)+1)):
407 |             #    self.__initializeMemory__(core);
408 |             ##apply toggling on operands
409 |             for key in list(self.toggleInstructionsList.keys()):
410 |                 self.toggleInstructionsList[key]=1; #first initialize dictionay
411 |             for ins in individual.getInstructions():
412 |                 if(ins.toggleable=="True"):
413 |                     if(int(self.toggleInstructionsList[ins.name])%2==1):
414 |                         ins.toggle(0);
415 |                     else:
416 |                         ins.toggle(1);
417 |                     self.toggleInstructionsList[ins.name]+=1;         
418 |             #dump the individual into mail loop of main.s
419 |             for line in fileinput.input(self.compilationDir+"/main.s", inplace=1):
420 |                 if "loop_code" in line:     
421 |                     print(individual);
422 |                 else:
423 |                     print(line,end="");
424 |             fileinput.close();
425 |             '''at last do the actual measurement'''
426 |             measurements= self.__doTheMeasurement__()
427 |             return measurements;
428 |         
429 |     '''def __saveIndiv__(self,individual):
430 |             #####before each individual bring back the original copy of main and startup    
431 |             self.__bring_back_code_template__();
432 |             ####initialize register values in main.s
433 |             #self.__initializeRegisterValues__();
434 |             ####dump memory initialization in startup.s for each core
435 |             #for core in range(1,int(int(self.cores)+1)):
436 |             #    self.__initializeMemory__(core);
437 |             ##apply toggling on operands
438 |             for key in list(self.toggleInstructionsList.keys()):
439 |                 self.toggleInstructionsList[key]=1; #first initialize dictionay
440 |             for ins in individual.getInstructions():
441 |                 if(ins.toggleable=="True"):
442 |                     if(int(self.toggleInstructionsList[ins.name])%2==1):
443 |                         ins.toggle(0);
444 |                     else:
445 |                         ins.toggle(1);
446 |                     self.toggleInstructionsList[ins.name]+=1;         
447 |             #dump the individual into mail loop of main.s
448 |             for line in fileinput.input(self.compilationDir+"/main.s", inplace=1):
449 |                 if "loop_code" in line:
450 |                     print(individual);
451 |                 else:
452 |                     print(line,end="");
453 |             fileinput.close();'''
454 |  
455 |         
456 |     def __bring_back_code_template__(self):
457 |             #####before each individual bring back the original copy of main and startup
458 |             if(os.path.exists(self.compilationDir +"main.s")):
459 |                 os.remove(self.compilationDir +"main.s")
460 |             shutil.copy(self.compilationDir +"main_original.s", self.compilationDir +"main.s")
461 |             
462 |             
463 |             if(os.path.exists(self.compilationDir +"startup.s")):
464 |                 os.remove(self.compilationDir +"startup.s")
465 |             #shutil.copy(self.compilationDir +"startup_original.s", self.compilationDir +"startup.s")
466 |     
467 |         
468 |     def __doTheMeasurement__(self):
469 |         self.measurement.setSourceFilePath(self.compilationDir+"/main.s")
470 |         return self.measurement.measure() 
471 |         
472 |     def __randomlyCreateIndividual__ (self):
473 |         instruction_sequence=[]
474 |         if self.percentage_clue=="True":
475 |             for ins_type in self.instruction_types.keys():##for each instruction type
476 |                 for i in range(self.instruction_types[ins_type]): ##create as many instructions as written in the hash
477 |                         instructions=self.instructions[ins_type];
478 |                         instruction_to_copy=instructions[self.rand.randint(0,instructions.__len__()-1)]; #choose random one instruction from the available types
479 |                         instruction=instruction_to_copy.copy();
480 |                         instruction.mutateOperands(self.rand); ##initialize randomy the instruction operands
481 |                         instruction_sequence.append(instruction);
482 |                         #print(instruction);
483 |             self.rand.shuffle(instruction_sequence);
484 |         else:
485 |             for i in range(int(self.loopSize)):
486 |                 instruction=self.rand.choice(self.allInstructionArray).copy();
487 |                 instruction.mutateOperands(self.rand);
488 |                 instruction_sequence.append(instruction);
489 |         newIndividual = Individual (instruction_sequence,self.populationsExamined)
490 |         return newIndividual;
491 |     
492 |     def areWeDone(self):
493 |         
494 |         '''if self.populationsToRun>0:
495 |             if self.populationsToRun==self.populationsTested:
496 |                 self.__saveIndiv__(self.bestIndividualUntilNow)
497 |                 return True
498 |         current_population_best=self.population.getFittest();
499 |         
500 |         if(self.bestIndividualUntilNow is None): #only for the first time
501 |             self.bestIndividualUntilNow=current_population_best;
502 |             self.waitCounter=0;
503 |             return False;
504 |         
505 |         if float(self.best_pop_target)>0 and current_population_best.getFitness()>=float(self.best_pop_target):
506 |             #SAVE BEST INDIV SOURCE
507 |             self.__saveIndiv__(current_population_best)
508 |             return True
509 |         
510 |         if float(self.avg_pop_target)>0 and self.population.getAvgFitness()>=float(self.avg_pop_target):
511 |             return True
512 |         
513 |         
514 |         if (float(current_population_best.getFitness()) < float(self.bestIndividualUntilNow.getFitness())):
515 |             self.waitCounter=self.waitCounter+1;
516 |         else:
517 |             improvement = float(current_population_best.getFitness()) / self.bestIndividualUntilNow.getFitness();
518 |             if (improvement - 1) < float(self.fitnessThreshold):
519 |                 self.waitCounter=self.waitCounter+1;
520 |             else:
521 |                 self.waitCounter=0;
522 |             self.bestIndividualUntilNow=current_population_best;'''
523 |         self.waitCounter=self.waitCounter+1
524 |         if int(self.waitCounter) == int(self.populationsToRun):
525 |             return True;
526 |         else:
527 |             return False;
528 |         
529 |     def __roulletteWheelSelection__ (self):
530 |         individuals=self.population.individuals;
531 |         turn=self.rand.randint(0,individuals[individuals.__len__()-1].cumulativeFitness);
532 |         for indiv in self.population.individuals:
533 |             if(int(indiv.cumulativeFitness)>=turn):
534 |                 return indiv; #return the first indiv that is equal or bigger to the random generated value
535 |             
536 |     def __tournamentSelection__(self):
537 |         tournamentIndiv=[];
538 |         for j in range(0,int(self.tournamentSize)):
539 |             tournamentIndiv.append(self.population.pickRandomlyAnIndividual(self.rand));
540 |         tournamentPop=Population(tournamentIndiv);
541 |         return tournamentPop.getFittest();
542 |             
543 |     def evolvePopulation (self): 
544 |         #individuals=[0]*int(self.populationSize);
545 |         individuals=[];
546 |         individuals2=[];
547 |         self.bestIndividualUntilNow=self.population.getFittest()
548 |         if self.ellitism=="true": #TODO make the choice to keep more individuals from previous populations TODO FIX THE true
549 |             individuals.append(self.bestIndividualUntilNow);
550 |             self.bestIndividualUntilNow.generation+=1; #For the next measurement the promoted individuals will be recorded as individuals of the next population.. Is just for avoiding confusions when processing the results 
551 |             childsCreated=1;
552 |         else:
553 |             childsCreated=0;
554 |         if(self.selectionMethod==Algorithm.WHEEL_SELECTION): 
555 |             self.population.keepHalfBest();##sightly algorithm change apply roullete on best 50%
556 |             self.population.setCumulativeFitness(); 
557 |         
558 |         while childsCreated<int(self.populationSize):
559 |             if(self.selectionMethod==Algorithm.WHEEL_SELECTION):
560 |                 # Create two children by crossovering two parent selected with the wheel method
561 |                 indiv1=self.__roulletteWheelSelection__();
562 |                 indiv2=self.__roulletteWheelSelection__();
563 |                 #while(indiv1==indiv2):
564 |                     #indiv2=self.__roulletteWheelSelection__();##the parents must be different TODO check how others do it
565 |             else:#tournament
566 |                 indiv1=self.__tournamentSelection__();
567 |                 indiv2=self.__tournamentSelection__();
568 |             
569 |             if(self.rand.random()<=float(self.crossoverRate)): #According to some sources there should be a slight chance some parents to not change , hence the crossoverRate parameter 
570 |                 if(self.crossoverType==Algorithm.UNIFORM_CROSSOVER):
571 |                     children=self.__uniform_crossover__(indiv1, indiv2);
572 |                 elif (self.crossoverType==Algorithm.ONEPOINT_CROSSOVER):
573 |                     children=self.__onePoint_crossover__(indiv1, indiv2)
574 |             else:
575 |                 children=[];
576 |                 children.append(indiv1);
577 |                 children.append(indiv2);
578 |                 
579 |             for child in children: 
580 |                 self.__mutation__(child); #mutate each child and add it to the list
581 |                 child.fixUnconditionalBranchLabels();##Due to crossover and mutation we must fix any possible duplicate branch labels
582 |                 individuals.append(child); #I don't want to waste any child so some populations can be little bigger in number of individuals
583 |                 childsCreated+=1;
584 |                      
585 |         self.population = Population(individuals);
586 |         
587 |         
588 |     def __mutation__ (self,individual):##options for mutation whole instructions or instruction's operands
589 |         instructions=individual.getInstructions();
590 |         for i in range(instructions.__len__()):
591 |             if self.rand.random()<=float(self.mutationRate):
592 |                 instruction=self.rand.choice(self.allInstructionArray).copy(); #choose random one instruction
593 |                 instruction.mutateOperands(self.rand); ##initialize randomy the instruction operands
594 |                 instructions[i]=instruction;
595 |                 '''if(self.rand.randint(0,1) ==1): #in this case change the whole instructions
596 |                     instruction=self.rand.choice(self.allInstructionArray).copy(); #choose random one instruction
597 |                     instruction.mutateOperands(self.rand); ##initialize randomy the instruction operands
598 |                     instructions[i]=instruction;
599 |                 else: #in this case just mutate the operands
600 |                     instructions[i].mutateOperands(self.rand)'''
601 |                 
602 |     def __uniform_crossover__(self,individual1,individual2):#creates two new individuals
603 |         #newIndiv=Individual(); TODO find out this weird bug.. for some reason the newIndiv wasn't reinitialized;;;This is the default behaviour of python when I use a muttable object for optional parameter
604 |         loop_code1=[];
605 |         loop_code2=[]
606 |         for i in range(int(self.loopSize)):
607 |             if(self.rand.random()<=float(self.uniformRate)): #do crossover
608 |                 loop_code1.append(individual2.getInstruction(i).copy());
609 |                 loop_code2.append(individual1.getInstruction(i).copy());
610 |             else: #keep instruction as it is
611 |                 loop_code1.append(individual1.getInstruction(i).copy());
612 |                 loop_code2.append(individual2.getInstruction(i).copy());
613 |         children=[];
614 |         children.append(Individual(sequence=loop_code1,generation=self.populationsExamined));
615 |         children.append(Individual(sequence=loop_code2,generation=self.populationsExamined));
616 |         children[0].setParents(individual1,individual2); ##the first parent is the code that remains the same.. the second parent is the code that came after crossover
617 |         children[1].setParents(individual2,individual1);
618 |         return children; 
619 |     
620 |     def __onePoint_crossover__(self,individual1,individual2):#creates two new individuals
621 |         #newIndiv=Individual(); TODO find out this weird bug.. for some reason the newIndiv wasn't reinitialized;;;This is the default behaviour of python when I use a muttable object for optional parameter # Solved look here for the answer http://stackoverflow.com/questions/1132941/least-astonishment-in-python-the-mutable-default-argument
622 |         loop_code1=[];
623 |         loop_code2=[]
624 |         crossover_point = self.rand.choice(range(int(self.loopSize)-1));
625 |         for i in range(int(self.loopSize)):
626 |             if(i>crossover_point):
627 |                 #do crossover
628 |                 loop_code1.append(individual2.getInstruction(i).copy());
629 |                 loop_code2.append(individual1.getInstruction(i).copy());
630 |             else: #keep instruction as it is
631 |                 loop_code1.append(individual1.getInstruction(i).copy());
632 |                 loop_code2.append(individual2.getInstruction(i).copy());
633 |         children=[];
634 |         children.append(Individual(sequence=loop_code1,generation=self.populationsExamined));
635 |         children.append(Individual(sequence=loop_code2,generation=self.populationsExamined));
636 |         children[0].setParents(individual1,individual2); ##the first parent is the code that remains the same.. the second parent is the code that came after crossover
637 |         children[1].setParents(individual2,individual1);
638 |         return children; 
639 |     
640 |     #def getFittest(self):
641 |     #    return self.bestIndividualUntilNow;
642 |     
643 | 


--------------------------------------------------------------------------------
/src/Fitness/DefaultFitness.py:
--------------------------------------------------------------------------------
 1 | '''
 2 | Copyright 2019 ARM Ltd. and University of Cyprus
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, 
 4 | including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, 
 5 | and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 6 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 8 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
 9 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
10 | '''
11 | 
12 | class DefaultFitness(object):
13 |     '''
14 |     classdocs
15 |     '''
16 | 
17 |     '''
18 |     Constructor
19 |     '''
20 |     def __init__(self):
21 |         
22 |         
23 |         '''Override getFitness to specify other fitness functions  
24 |         should be called after individual measurements are set (in other words the individual object instance at this point should carry the measurements with it)
25 |         The getFitness function can be very sophisticated 
26 |         e.g. take in account instruction count instruction mix, various metrics like perf counters power etc
27 |         the getfitness should return an array where the first the first item MUST be the finess value, followed by any other useful information the user would like to see on file name of the indiviudal
28 |         such as specific components ued to calculate the fitness and the individual measurements (like in the below example)
29 |         To use the user defined fitness function specify the class name in the fitnessClass parameter in the configuration file
30 |         '''
31 |         
32 |     def getFitness(self,individual): 
33 |         fitness=individual.getMeasurements()[0]
34 |         toReturn=[]
35 |         toReturn.append(fitness)
36 |         for value in individual.getMeasurements():
37 |             toReturn.append(value)
38 |         return toReturn


--------------------------------------------------------------------------------
/src/Fitness/SimplicityTempFitness.py:
--------------------------------------------------------------------------------
 1 | '''
 2 | Copyright 2019 ARM Ltd. and University of Cyprus
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, 
 4 | including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, 
 5 | and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 6 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 8 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
 9 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
10 | '''
11 | 
12 | class SimplicityTempFitness(object): # a fitness function for maximizing both temperature and instruction stream simplicity
13 |     '''
14 |     classdocs
15 |     '''
16 |     
17 |     '''
18 |     Constructor
19 |     '''
20 |     def __init__(self):
21 |         self.MAX_TEMP=100
22 |         self.BASELINE_TEMP=40
23 |         self.MAX_TEMP_SCORE=self.MAX_TEMP-self.BASELINE_TEMP
24 |         self.percentages=[0.5,0.5]
25 |     
26 |         
27 |         '''Override this function to specify other fitness functions  
28 |         should be called after individual measurements are set (in other words the individual object instance at this point should carry the measurements with it)
29 |         The getFitness function can be very sophisticated 
30 |         e.g. take in account instruction count instruction mix, various metrics like perf counters power etc
31 |         the getfitness should return an array where the first the first item MUST be the finess value, followed by any other useful information the user would like to see on file name of the indiviudal
32 |         such as specific components ued to calculate the fitness and the individual measurements (like in the below example)
33 |         To use the user defined fitness function specify the class name in the fitnessClass parameter in the configuration file
34 |         '''
35 |         
36 |     def getFitness(self,individual): 
37 |         insHash={}
38 |         instructions=individual.getInstructions()
39 |         totalInstructions=len(instructions)
40 |         
41 |         for ins in instructions:
42 |             insHash[ins.name]=1
43 |         uniqueIns=len(insHash.keys())
44 |         
45 |         tempScore=(individual.getMeasurements()[0]-self.BASELINE_TEMP) / self.MAX_TEMP_SCORE
46 |         tempScoreWeighted=tempScore*self.percentages[0]
47 |         
48 |         instructionsScore=(totalInstructions - uniqueIns)/totalInstructions
49 |         instructionsScoreWeighted=instructionsScore*self.percentages[1]
50 |         
51 |         fitness=tempScoreWeighted+instructionsScoreWeighted 
52 |         
53 |         toReturn=[]
54 |         toReturn.append(fitness)
55 |         toReturn.append(tempScoreWeighted)
56 |         toReturn.append(instructionsScoreWeighted)
57 |         for value in individual.getMeasurements():
58 |             toReturn.append(value)
59 |         return  toReturn


--------------------------------------------------------------------------------
/src/Individual.py:
--------------------------------------------------------------------------------
  1 | '''
  2 | Copyright 2019 ARM Ltd. and University of Cyprus
  3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, 
  4 | including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, 
  5 | and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
  6 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
  7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
  8 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
  9 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 10 | '''
 11 | import pickle;
 12 | import copy;
 13 | 
 14 | class Individual(object):
 15 |     '''
 16 |     classdocs
 17 |     '''
 18 |     id=0;
 19 | 
 20 |     def __init__(self,sequence=[],generation=0): #Note This code assumes that instruction operands are initiated (mutated) from before
 21 |         Individual.id+=1;
 22 |         self.myId=Individual.id;
 23 |         self.sequence=sequence;
 24 |         self.fitness=0.0; 
 25 |         #self.secondaryMeasurement=0.0;
 26 |         self.measurements=[]
 27 |         self.branchLabels={};
 28 |         self.cumulativeFitness=0.0; #for wheel selection
 29 |         self.parents=[];
 30 |         self.generation=generation;
 31 |         self.fixUnconditionalBranchLabels();
 32 |         return;
 33 |     
 34 |     def addInstruction(self,anInstruction):
 35 |         self.sequence.append(anInstruction);
 36 |     
 37 |     def getInstruction(self,index):
 38 |         return self.sequence[index];
 39 |     
 40 |     def getInstructions(self):
 41 |         return self.sequence;
 42 |     
 43 |     def fixUnconditionalBranchLabels(self):
 44 |         automatically_incremented={};
 45 |         for ins in self.sequence:
 46 |             for operand in ins.getOperands():
 47 |                 if(operand.type=="automatically_incremented_operand"): 
 48 |                     if(operand.id in automatically_incremented.keys()):
 49 |                         automatically_incremented[operand.id]+=int(operand.stride);
 50 |                     else:
 51 |                         automatically_incremented[operand.id]=int(operand.min);
 52 |                     operand.currentValue=automatically_incremented[operand.id];
 53 |     
 54 |     def setMeasurementsVector(self,measurements):#by convention the first item of the vector is the fitness value
 55 |         self.measurements=measurements
 56 |     
 57 |     def setFitness(self,fitness):
 58 |         self.fitness=fitness
 59 |     
 60 |     '''def setMeasurementsVector(self,measurements): 
 61 |         self.measurements=measurements
 62 |         return;'''
 63 |     
 64 |     def setCumulativeFitness(self,fitness): #for wheel selection
 65 |         self.cumulativeFitness=fitness;
 66 |     
 67 |     def getFitness(self):
 68 |         try:
 69 |             return self.fitness; #by convention the first item of the vector is the fitness value
 70 |         except:
 71 |             return self.measurement #to support continuing runs from legacy population pkls
 72 |     #def getSecondaryMeasurement(self):
 73 |     #    return self.secondaryMeasurement;
 74 |     def getMeasurements(self):
 75 |         return self.measurements
 76 |     
 77 |     def setParents(self,par1,par2): ##the first parent is the code that remains the same.. the second parent is the code that came after crossover
 78 |         self.parents.append(par1);
 79 |         self.parents.append(par2);
 80 |     
 81 |     def clearParents(self):
 82 |         self.parents=None;
 83 |     
 84 |     def belongsToInitialSeed(self):
 85 |         if self.parents:
 86 |             return False;
 87 |         else:
 88 |             return True;
 89 |         
 90 |     def __str__(self):
 91 |         index=0;
 92 |         output=""
 93 |         for ins in self.sequence:
 94 |             output+=str("\t"+ins.__str__()+"\n");
 95 |             if str(index) in self.branchLabels.keys():
 96 |                 output+=str(self.branchLabels[str(index)]+"\n");
 97 |             index+=1;
 98 |         return output;
 99 |     
100 |     def __cmp__(self,other):
101 |         if self.getFitness()  < other.getFitness():
102 |             return -1
103 |         elif self.getFitness()> other.getFitness():
104 |             return 1
105 |         else:
106 |             return 0
107 |         
108 |     def pickle(self,filename):
109 |         pickle.dump(self, filename);
110 |     
111 |     @staticmethod
112 |     def unpickle(filename):
113 |         return pickle.load(filename);
114 |     
115 |     def copy(self):
116 |         return copy.deepcopy(self);
117 |     


--------------------------------------------------------------------------------
/src/Instruction.py:
--------------------------------------------------------------------------------
 1 | '''
 2 | Copyright 2019 ARM Ltd. and University of Cyprus
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, 
 4 | including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, 
 5 | and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 6 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 8 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
 9 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
10 | '''
11 | import copy
12 | import sys;
13 | 
14 | 
15 | class Instruction(object):
16 |     '''
17 |     classdocs
18 |     '''
19 | 
20 | 
21 |     def __init__(self,name,ins_type,numOfOperands,operands=[],format="op1,op2,op3",toggleable="False"):
22 |         '''
23 |         Constructor
24 |         '''
25 |         self.name = name;
26 |         self.ins_type = ins_type;
27 |         self.operands = operands;
28 |         self.format=format;
29 |         self.format=self.format.replace("\\n","\n"); #replace double backslashes with one backslash to make sure atomic sequences work. for some reason the xml parsing by default ads a backslash to escape characters
30 |         self.format=self.format.replace("\\t","\t");
31 |         self.numOfOperands = numOfOperands;
32 |         self.toggleable=toggleable;
33 |         
34 |     def copy(self):
35 |         return copy.deepcopy(self);
36 |             
37 |         
38 |     def setOperands (self,operands):
39 |         self.operands=operands;
40 |         
41 |     def getOperand(self,index=0):
42 |         if (index>=self.operands.__len__() or index <0):
43 |             print("error index out of bounds")
44 |             sys.exit;
45 |         return self.operands[index];
46 |     
47 |     def getOperands(self):
48 |         return self.operands;
49 |     
50 |     def toggle(self,value_index): #It's the algorithm class job to provide the right indexes for toggling
51 |         for op in self.operands:
52 |                 if(op.toggleable=="True"):
53 |                     op.setCurrentValueByIndex(value_index);
54 |                       
55 |         
56 |     def mutateOperands (self,rand):##TODO maybe give an option of changing particular operands
57 |         for op in self.operands:
58 |             op.mutate(rand);
59 |             
60 |     ''' def toggle(self): #TODO think if you really need this
61 |        '''
62 |            
63 |         
64 |     def __str__ (self):
65 |         
66 |         if( (str(self.numOfOperands).strip() == "0") or (self.operands[0].currentValue!= "") ):
67 |             representation=self.format
68 |             for i in range(0,self.operands.__len__()):
69 |                 toReplace="op"+str(i+1);
70 |                 representation=representation.replace(toReplace.__str__(),str(self.operands[i].__str__()));
71 | 
72 |             #representation=self.name + " " + representation
73 |             return representation
74 |         else:
75 |             representation="name "+self.name + "\ntype "+self.ins_type +"\nformat "+self.format+"\nnumOfOperands "+self.numOfOperands+"\n";
76 |             for i in range(int(self.numOfOperands)):
77 |                 representation+=("\t"+str(self.operands[i])+"\n");
78 |             return representation;
79 | 
80 | 


--------------------------------------------------------------------------------
/src/Measurement/Measurement.py:
--------------------------------------------------------------------------------
  1 | '''
  2 | Copyright 2019 ARM Ltd. and University of Cyprus
  3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, 
  4 | including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, 
  5 | and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
  6 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
  7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
  8 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
  9 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 10 | '''
 11 | 
 12 | from abc import ABC, abstractmethod
 13 | from xml.dom import minidom
 14 | from paramiko import SSHClient, client
 15 | import paramiko
 16 | import socket
 17 | import platform
 18 | import visa
 19 | import os
 20 | 
 21 | class Measurement(ABC):
 22 |     '''
 23 |     classdocs
 24 |     '''
 25 | 
 26 |     def __init__(self, confFile):
 27 |         '''
 28 |         Constructor
 29 |         '''
 30 |         self.confFile=confFile
 31 |         self.xmldoc = minidom.parse(confFile)
 32 |         
 33 |         #most of the below are expected to be initialized in init function (should be called after constructor)
 34 |         self.targetRunDir= None
 35 |         self.targetHostname= None
 36 |         self.targetSSHusername= None
 37 |         self.targetSSHpassword = None
 38 |         self.coresToUse=None
 39 |         self.sourceFilePath=None #to be set in setSourceFilePath funtion
 40 |         super().__init__() #abstract class init
 41 |         
 42 |     def init(self): #should be called after constructor.. this can be overridden by child measurement classes to add new or use other configuration parameters..
 43 | 
 44 |         self.targetRunDir= self.tryGetStringValue('targetRunDir')
 45 |         self.targetHostname= self.tryGetStringValue('targetHostname')
 46 |         self.targetSSHusername= self.tryGetStringValue('targetSSHusername')
 47 |         self.targetSSHpassword = self.tryGetStringValue('targetSSHpassword')
 48 |         coresToUseString=self.tryGetStringValue('coresToUse')
 49 |         self.coresToUse=[]
 50 |         for core in coresToUseString.split(" "):
 51 |             self.coresToUse.append(int(core))
 52 |     
 53 |     def setSourceFilePath(self,sourceFilePath): #should be called before measurement or in the begining of the GA run if the source file path doesn't changes
 54 |         self.sourceFilePath=sourceFilePath
 55 |         
 56 |     ##helper functions to make clearer the code.. on exception the code doesn't terminate immediately but it does produce a warning message.. 
 57 |     ##This is the case because sometimes this might be desirable based on the functionality.. For instance bare metal runs won't use the ssh parameters 
 58 |     def tryGetStringValue(self,key):
 59 |         try:
 60 |             value=self.xmldoc.getElementsByTagName(key)[0].attributes['value'].value;
 61 |             return value
 62 |         except:
 63 |             print("Warning failed to read "+str(key))
 64 |         
 65 |     def tryGetIntValue(self,key):
 66 |         try:
 67 |             value=int(self.xmldoc.getElementsByTagName(key)[0].attributes['value'].value);
 68 |             return value
 69 |         except:
 70 |             print("Warning failed to read "+str(key))
 71 |     
 72 |     def tryGetFloatValue(self,key):
 73 |         try:
 74 |             value=float(self.xmldoc.getElementsByTagName(key)[0].attributes['value'].value);
 75 |             return value
 76 |         except:
 77 |             print("Warning failed to read "+str(key))
 78 |         
 79 |     #this function should return an array of results.. at least one item should be returned.. the defaultFitness.py class (that calculates indidual's fitness) assumes by convention that the first array
 80 |     #item is the fitness value 
 81 |     @abstractmethod
 82 |     def measure(self): 
 83 |         pass
 84 |     
 85 |     ## utility function for executing commands over ssh connection.. very common functionality
 86 |     def executeSSHcommand(self,command,continousAttempt=True,max_tries=10):
 87 |         tries=0
 88 |         while True:
 89 |             try:
 90 |                 ssh = SSHClient()
 91 |                 ssh.set_missing_host_key_policy(client.AutoAddPolicy()) 
 92 |                 ssh.connect(self.targetHostname, username=self.targetSSHusername, password=self.targetSSHpassword)
 93 |                 stdin,stdout,stderr =ssh.exec_command(command)
 94 |                 lines=[]
 95 |                 for line in stdout.readlines():
 96 |                     lines.append(line)
 97 |                 ssh.close()
 98 |                 return lines
 99 |                 
100 |             except:
101 |                 if continousAttempt and tries<max_tries:
102 |                     tries=tries+1
103 |                     continue
104 |                 else:
105 |                     raise("Exception: Unable to execute command "+str(command))
106 |     
107 |     def executeSSHcommandNonBlocking(self,command,continousAttempt=True,max_tries=10):
108 |         tries=0
109 |         while True:
110 |             try:
111 |                 ssh = SSHClient()
112 |                 ssh.set_missing_host_key_policy(client.AutoAddPolicy()) 
113 |                 ssh.connect(self.targetHostname, username=self.targetSSHusername, password=self.targetSSHpassword)
114 |                 ssh.exec_command(command)
115 |                 ssh.close()
116 |                 return
117 |             except:
118 |                 if continousAttempt and tries<max_tries:
119 |                     tries=tries+1
120 |                     continue
121 |                 else:
122 |                     raise("Exception: Unable to execute command "+str(command))
123 |                 
124 |     #### utility function for copying the source file over ssh connection.. very common functionality        
125 |     def copyFileOverFTP(self,continousAttempt=True):
126 |         while True:
127 |             try:
128 |                 ssh = SSHClient()
129 |                 ssh.set_missing_host_key_policy(client.AutoAddPolicy()) 
130 |                 ssh.connect(self.targetHostname, username=self.targetSSHusername, password=self.targetSSHpassword)
131 |                 sftp=ssh.open_sftp();
132 |                 sftp.put(self.sourceFilePath,self.targetRunDir+"/main.s")
133 |                 sftp.close()
134 |                 ssh.close()
135 |                 break    
136 |             except:
137 |                 if continousAttempt:
138 |                     continue
139 |                 else:
140 |                     raise("Exception: Unable to copy file")
141 |         
142 |         
143 |     def ping (self,host):
144 |         """
145 |         Returns True if host responds to a ping request
146 |         """
147 |         # Ping parameters as function of OS
148 |         ping_str = "-n 1" if  platform.system().lower()=="windows" else "-c 1"
149 |         
150 |         # Ping
151 |         return os.system("ping " + ping_str + " " + host) == 0  
152 |             
153 |     
154 |     


--------------------------------------------------------------------------------
/src/Measurement/MeasurementIPC.py:
--------------------------------------------------------------------------------
 1 | '''
 2 | Copyright 2019 ARM Ltd. and University of Cyprus
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, 
 4 | including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, 
 5 | and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 6 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 8 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
 9 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
10 | '''
11 | 
12 | from Measurement.Measurement import Measurement
13 | 
14 | class MeasurementIPC(Measurement):
15 |     '''
16 |     classdocs
17 |     '''
18 |     
19 |     def __init__(self,confFile):
20 |         super().__init__(confFile)
21 |      
22 |     
23 |     def init(self):
24 |         super().init()
25 |         self.timeToMeasure = self.tryGetIntValue('time_to_measure')
26 |     
27 |     def measure(self):  
28 | 
29 |         super().copyFileOverFTP()
30 |         compilation_command="cd "+self.targetRunDir + " ; gcc main.s -o individual &>/dev/null;"
31 |         execution_command="cd "+self.targetRunDir + " ; ./individual & perf stat -e instructions,cycles -o tmp -p $! sleep "+str(self.timeToMeasure) +" ; pkill individual &> /dev/null;"
32 |         output_command="cd "+self.targetRunDir + " ; cat tmp | grep insn | tr  ',' '.' | awk '{print $4}'; rm main.s; rm individual; rm tmp; ";
33 |         super().executeSSHcommand(compilation_command)
34 |         super().executeSSHcommand(execution_command)
35 |         stdout=super().executeSSHcommand(output_command)
36 |                 
37 |         ipc=0            
38 |         
39 |         for line in stdout:
40 |             #print ("line is "+line)
41 |             try:
42 |                 test=float(line)
43 |                 ipc=test
44 |             except ValueError:
45 |                 print ("Exception line not ipc")
46 |    
47 | 
48 |         measurements=[];
49 |         measurements.append(ipc);
50 |         return measurements;
51 |             #return ipc;
52 | 


--------------------------------------------------------------------------------
/src/Measurement/MeasurementLikwidPower.py:
--------------------------------------------------------------------------------
 1 | '''
 2 | Copyright 2019 ARM Ltd. and University of Cyprus
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, 
 4 | including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, 
 5 | and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 6 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 8 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
 9 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
10 | '''
11 | 
12 | from Measurement.Measurement import Measurement
13 | 
14 | class MeasurementLikwidPower(Measurement):
15 |     '''
16 |     classdocs
17 |     '''
18 |     
19 |     def __init__(self,confFile):
20 |         super().__init__(confFile)
21 |      
22 |     
23 |     def init(self):
24 |         super().init()
25 |         self.timeToMeasure = self.tryGetIntValue('time_to_measure')
26 |     
27 |     #the below code is tested to work with likwid 4.3 and 3.1 versions
28 |     
29 |     def measure(self):  
30 |             
31 |         super().copyFileOverFTP()
32 |         compilation_command="cd "+self.targetRunDir + " ; gcc main.s -o individual &>/dev/null;"
33 |         execution_command="cd "+self.targetRunDir+" ; "
34 |         for core in self.coresToUse:
35 |                 execution_command+="taskset -c "+str(core)+" ./individual  &>/dev/null &  "
36 |         execution_command+=" sudo likwid-powermeter  -s "+str(self.timeToMeasure) +"s > tmp ; pkill individual &> /dev/null;" #make sure that msr module is loaded (modprobe msr) and sudo without password is enabled
37 |         output_command="cd "+self.targetRunDir + " ; cat tmp | grep Watt | head -n 1 | awk '{print $3}'; rm main.s; rm individual; rm tmp; "; #this grabs the package power
38 |         super().executeSSHcommand(compilation_command)
39 |         super().executeSSHcommand(execution_command)
40 |         stdout=super().executeSSHcommand(output_command)
41 |                      
42 |         
43 |         for line in stdout:
44 |             try:
45 |                 test=float(line)
46 |                 power_meas=test
47 |             except ValueError:
48 |                 print ("Exception line not power")
49 |    
50 | 
51 |         measurements=[];
52 |         measurements.append(power_meas);
53 |         
54 |         return measurements;
55 |             


--------------------------------------------------------------------------------
/src/Operand.py:
--------------------------------------------------------------------------------
 1 | '''
 2 | Copyright 2019 ARM Ltd. and University of Cyprus
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, 
 4 | including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, 
 5 | and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 6 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 8 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
 9 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
10 | '''
11 | import copy
12 | import sys
13 | class Operand(object):  
14 |     '''
15 |     classdocs
16 |     '''
17 |     
18 | 
19 |     def __init__(self,id,type,values=[],min=0,max=4294967296,stride=1,toggleable="False"): 
20 |         '''Constructor takes as parameters the values an operand can take either in array or in bounds format'''
21 |         self.values = values;
22 |         self.min = min;
23 |         self.max = max;
24 |         self.stride = stride;
25 |         self.currentValue="";
26 |         self.id=id;
27 |         self.type=type;
28 |         self.toggleable=toggleable
29 |         if( (int(min)>int(max)) or (int(stride)<=0)):
30 |             print("Watch out you should always put a stride above 0 otherwise an infinitive loop will be caused and min should be less or equal than max");
31 |             sys.exit();
32 |         if not self.values: #if possible values not set.. manually create them
33 |             if(self.type!="automatically_incremented_operand"): #some types are automatically implemented e.g. branch labels
34 |                 i=int(self.min);
35 |                 while(i<=int(self.max)):
36 |                     self.values.append(i);
37 |                     i+=int(self.stride);      
38 |         #self.togleValue=self.values[0];
39 |              
40 |     def copy(self):
41 |         return copy.deepcopy(self);
42 |     
43 |     def mutate(self,rand):
44 |         '''Basicaly sets as current value a random value from the acceptable range'''
45 |         if(self.type=="automatically_incremented_operand"):
46 |             self.currentValue=self.min;
47 |         else:    
48 |             self.currentValue=rand.choice(self.values);
49 |         
50 |         
51 |     def getValue(self):
52 |         return self.currentValue;
53 |     
54 |     def setCurrentValueByIndex(self,index):
55 |         self.currentValue=self.values[index];
56 |     
57 |     '''def toggle(self): 
58 |         if(self.toggleable=="True"): 
59 |             if(self.togleValue==self.values[0]):
60 |                 self.togleValue=self.values[1];
61 |             else:
62 |                 self.togleValue=self.values[0];
63 |                 
64 |         def setToggleValueAsCurrent(self):
65 |         if(self.toggleable=="True"):
66 |             self.currentValue=self.togleValue;'''
67 |     
68 |     def __str__(self):
69 |         if(self.currentValue != ""):
70 |             return str(self.currentValue);
71 |         else:
72 |             return str(self.id);
73 | 
74 | 


--------------------------------------------------------------------------------
/src/Population.py:
--------------------------------------------------------------------------------
 1 | '''
 2 | Copyright 2019 ARM Ltd. and University of Cyprus
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, 
 4 | including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, 
 5 | and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 6 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 8 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
 9 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
10 | '''
11 | 
12 | import operator
13 | import pickle
14 | 
15 | class Population(object):
16 |     '''
17 |     classdocs
18 |     '''
19 | 
20 | 
21 |     def __init__(self,individuals=[]):
22 |         self.individuals=individuals;
23 |         
24 |     
25 |     def getIndividual(self,index):
26 |         return self.individuals[index];
27 |         
28 |     def getFittest(self):
29 |         best_value=float(self.individuals[0].getFitness());
30 |         best_indiv=self.individuals[0];
31 |         for i in range (self.individuals.__len__()):
32 |             if float(self.individuals[i].getFitness()) > best_value:
33 |                 best_value=float(self.individuals[i].getFitness()) 
34 |                 best_indiv=self.individuals[i];        
35 |         return best_indiv;
36 |     
37 |     def getAvgFitness(self):
38 |         sum=0
39 |         for indiv in self.individuals:
40 |             sum+=float(indiv.getFitness())
41 |         avg=sum/self.individuals.__len__()
42 |         return avg
43 |     def getSize (self):
44 |         return self.individuals.__len__()
45 |     
46 |     def pickRandomlyAnIndividual(self,rand):
47 |         return rand.choice(self.individuals);
48 |         
49 |     def setCumulativeFitness(self): #for roulette wheel selection
50 |         sum=0.0;
51 |         self.individuals[0].setCumulativeFitness(int(self.individuals[0].getFitness()*1000000));
52 |         for i in range(1,self.individuals.__len__()):
53 |             fitness=int(self.individuals[i].getFitness()*1000000);
54 |             self.individuals[i].setCumulativeFitness(self.individuals[i-1].cumulativeFitness+fitness);
55 |                     
56 |     def sortByFitessToWeakest(self):
57 |         self.individuals.sort(key=operator.attrgetter('fitness'),reverse=True)
58 |         
59 |     def sortByWeakestToFitess(self):
60 |         self.individuals.sort(key=operator.attrgetter('fitness'))
61 |         #sorted(self.individuals,key=lambda obj: obj.fitness, reverse=True);
62 |     
63 |     def saveIndividual (self,index,individual):
64 |         self.individuals[index]=individual;
65 |         
66 |     def __str__(self):
67 |         output="";
68 |         for code in self.individuals:
69 |             output+=str(code.__str__()+"\n");
70 |         return output;
71 |     
72 |     def keepHalfBest(self):
73 |         self.sortByFitessToWeakest();
74 |         half=int(self.individuals.__len__()/2);
75 |         newList=[]
76 |         for i in range(0,half):
77 |             newList.append(self.individuals[i]);
78 |         self.individuals=newList;
79 |         
80 |         
81 |     def pickle(self,filename):
82 |         pickle.dump(self, filename);
83 |         
84 |     @staticmethod
85 |     def unpickle(filename):
86 |         return pickle.load(filename);


--------------------------------------------------------------------------------
/src/__init__.py:
--------------------------------------------------------------------------------
 1 | '''
 2 | Copyright 2019 ARM Ltd. and University of Cyprus
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, 
 4 | including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, 
 5 | and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 6 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 8 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
 9 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
10 | '''
11 | import Instruction
12 | import Operand
13 | from random import Random
14 | from Algorithm import Algorithm
15 | from Individual import Individual
16 | import sys
17 | 
18 | 
19 | '''1st argument full path to configuration file.'''   
20 | 
21 | rand = Random ();  #to use a fixed seed give an int argument
22 | algorithm = Algorithm (sys.argv[1],rand) 
23 | algorithm.createInitialPopulation();
24 | algorithm.measurePopulation();
25 | while algorithm.areWeDone()!= True:
26 |     algorithm.evolvePopulation()
27 |     algorithm.measurePopulation()
28 | fittest=algorithm.getFittest();
29 | print ("Fittest individual is:\n " + fittest.__str__() + "with measurement equal to "+str(fittest.getMeasurement()));
30 | 
31 | 


--------------------------------------------------------------------------------
/src/parseGeneticResults.py:
--------------------------------------------------------------------------------
  1 | '''
  2 | Copyright 2019 ARM Ltd. and University of Cyprus
  3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, 
  4 | including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, 
  5 | and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
  6 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
  7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
  8 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
  9 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 10 | '''
 11 | import os
 12 | import sys
 13 | import pickle
 14 | import pprint;
 15 | from Population import Population
 16 | from Individual import Individual
 17 | from Instruction import Instruction
 18 | from Operand import Operand
 19 | import re;
 20 | 
 21 | 
 22 | path = sys.argv[1] 
 23 | files=[]
 24 | for root, dirs, filenames in os.walk(path): #takes as input the dir with the saved state
 25 |     for f in filenames:
 26 |         if((".pkl" in f) and ("rand" not in f)):
 27 |             files.append(f);
 28 | 
 29 | files.sort(key=lambda x:  int(x.split('.')[0]));
 30 | pop=Population([]);
 31 | allValues="";
 32 | allKeys="";
 33 | columns=[];
 34 | theBest=[];
 35 | print("best and average of each generation");
 36 | print("generation best average");
 37 | insHash={};
 38 | 
 39 | for f in files:
 40 |     input=open(path+f,"rb");
 41 |     pop=pickle.load(input);
 42 |     input.close();
 43 |     columns.append(f.split('.')[0]);
 44 |     best=pop.getFittest();
 45 |     theBest.append(best);
 46 |     sum=0.0;
 47 |     count=0;
 48 |     for indiv in pop.individuals:
 49 |         sum+=float(indiv.getFitness());
 50 |         count+=1;
 51 |         for ins in indiv.sequence:
 52 |             
 53 |                 if(ins.name in insHash.keys()):
 54 |                     insHash[ins.name]+=1;
 55 |                 else:
 56 |                     insHash[ins.name]=1;
 57 |     sorted(insHash,key=lambda key: insHash[key]);
 58 |     #print(insHash);
 59 |     allKeys+=list(insHash.keys()).__str__()+"\n";
 60 |     allValues+=insHash.values().__str__()+"\n";
 61 |     average=sum/count;
 62 |     for key in list(insHash.keys()): #clear the hash for the next population
 63 |         insHash[key]=0;
 64 |     
 65 |     print(str(columns[-1])+" "+str(round(float(best.getFitness()),6))+" "+str(round(float(average),6))  );
 66 | #print (allKeys);
 67 | print("end of generation best average");
 68 | 
 69 | values=re.sub("[A-Za-z]", "", allValues);
 70 | values=re.sub("[\[\]\(\),_]", "", values);
 71 | values=values.strip(' \n');
 72 | data=[];
 73 | totalSize=pop.individuals[0].getInstructions().__len__()*pop.getSize();
 74 | #print (values);
 75 | for row in values.split("\n"):
 76 |     #print(row);
 77 |     data.append([float(float(s)/float(totalSize)) for s in row.split()])
 78 |     #data.append([int(s) for s in row.split()])
 79 | #data=pprint.pformat (data);
 80 | 
 81 | 
 82 | rows=re.sub("[\[,\'\]]", "", allKeys);
 83 | rows=re.sub("[\{\}\':,]", "", rows);
 84 | rows=rows.strip(' \n');
 85 | 
 86 | for column in rows.split("\n"):
 87 |     #print(row);
 88 |     rows=[str(s) for s in column.split()]
 89 | 
 90 | 
 91 | print("Instruction Mix per generation");
 92 | 
 93 | print (" "+' '.join(rows));
 94 | 
 95 | for i in range(columns.__len__()):
 96 |     print (columns[i],end=" ");
 97 |     for j in range(rows.__len__()):
 98 |         print(round(data[i][j],2),end=" ");
 99 |     print("");
100 |     
101 | #print(values);
102 | 
103 | print("Instruction Mix for best of each generation");
104 | 
105 | print (" "+' '.join(rows));
106 | 
107 | 
108 | loopSize=theBest[0].getInstructions().__len__()
109 | 
110 | i=1;
111 | for indiv in theBest:
112 |     for key in list(insHash.keys()): #clear the hash for the next individual
113 |         insHash[key]=0;
114 |     for ins in indiv.sequence:
115 |                 if(ins.name in insHash.keys()):
116 |                     insHash[ins.name]+=1;
117 |                 else:
118 |                     insHash[ins.name]=1;
119 |     sorted(insHash,key=lambda key: insHash[key]);
120 |     print(str(i),end=" ");
121 |     i+=1;
122 |     for key in list(insHash.keys()):
123 |         print(round(float(float(insHash[key])/loopSize),2),end=" ");
124 |     print("");
125 | 
126 | print("Type Mix for best of each generation");
127 | 
128 | typeHash={};
129 | 
130 | i=1;
131 | for indiv in theBest:
132 |     for key in list(typeHash.keys()): #clear the hash for the next individual
133 |         typeHash[key]=0;
134 |     for ins in indiv.sequence:
135 |                 try:
136 |                     if(ins.type in typeHash.keys()):
137 |                         typeHash[ins.type]+=1;
138 |                     else:
139 |                         typeHash[ins.type]=1;
140 |                 except: #in legacy pkls the attribute was type instead of ins_type
141 |                     if(ins.ins_type in typeHash.keys()):
142 |                         typeHash[ins.ins_type]+=1;
143 |                     else:
144 |                         typeHash[ins.ins_type]=1;
145 |                     
146 |     sorted(typeHash,key=lambda key: typeHash[key]);
147 |     print(str(i),end=" ");
148 |     i+=1;
149 |     for key in list(typeHash.keys()):
150 |         print(round(float(float(typeHash[key])/loopSize),2),end=" ");
151 |     print("");
152 | for key in typeHash.keys():
153 |     print(key,end=" ")
154 | 
155 | sys.exit();
156 | 
157 | 


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