scripts/configurations.py

   1 import os
   2 import sys
   3 import tempfile
   4 import shutil
   5 import subprocess
   6 import time
   7 import hashlib
   8
   9 import utils
  10 from conf import conf
  11 from conf import sf
  12 import exceptions
  13 import database
  14
  15 def __buildtempcnf__(variable_count, files, strlines):
  16         """ Builds temporally file for cnf formulas
  17           variable_count - number of variables in formulas
  18           files          - list of files with formulas
  19           strlines       - list of string lines with formulas"""
  20         lines = set()
  21         # Copy strlines
  22         for ln in strlines:
  23                 lines.add(ln)
  24         # Files
  25         for file in files:
  26                 with open(file, 'r') as f:
  27                         for ln in f:
  28                                 lines.add(ln.rstrip())
  29
  30         first_line = "p cnf " + str(variable_count) + " " + str(len(lines))
  31
  32         wfile = tempfile.NamedTemporaryFile(delete=False)
  33         wfile.write(bytes(first_line + '\n', 'UTF-8'))
  34         for ln in lines:
  35                 wfile.write(bytes(ln + ' 0\n', 'UTF-8'))
  36         wfile.close()
  37         return wfile.name
  38
  39 def __exec_sat__(file, args):
  40         """Executes SAT solver and returns configuration."""
  41         picosat_cmd = [sf(conf.picosat), file]
  42         picosat_cmd += conf.picosat_args
  43         stdout = utils.callsubprocess('picosat', picosat_cmd, conf.picosat_output,
  44                         True, allow_all_exit_codes = True)
  45
  46         rtn = []
  47         solut = []
  48         for line in stdout:
  49                 if line[0] == 's':
  50                         try:
  51                                 solut.remove(0)
  52                                 rtn.append(solut)
  53                         except ValueError:
  54                                 pass
  55                         solut = []
  56                         if not line.rstrip() == 's SATISFIABLE':
  57                                 raise exceptions.NoSolution()
  58                 elif line[0] == 'v':
  59                         for sl in line[2:].split():
  60                                 solut.append(int(sl))
  61         try:
  62                 solut.remove(0)
  63                 rtn.append(solut)
  64         except ValueError:
  65                 pass
  66         return rtn
  67
  68 def __write_temp_config_file__(con, conf_num):
  69         # Ensure smap existence
  70         utils.build_symbol_map()
  71         # Write temporally file
  72         wfile = tempfile.NamedTemporaryFile(delete=False)
  73         for s in con:
  74                 if s < 0:
  75                         nt = True
  76                         s *= -1
  77                 else:
  78                         nt = False
  79                 if s > conf_num:
  80                         break;
  81                 if 'NONAMEGEN' in utils.smap[s]: # ignore generated names
  82                         continue
  83                 wfile.write(bytes('CONFIG_' + utils.smap[s] + '=',
  84                         sys.getdefaultencoding()))
  85                 if not nt:
  86                         wfile.write(bytes('y', sys.getdefaultencoding()))
  87                 else:
  88                         wfile.write(bytes('n', sys.getdefaultencoding()))
  89                 wfile.write(bytes('\n', sys.getdefaultencoding()))
  90         wfile.close()
  91         return wfile.name
  92
  93 def __load_config_file__(file):
  94         rtn = dict()
  95         with open(file, 'r') as f:
  96                 for ln in f:
  97                         if ln[0] == '#' or not '=' in ln:
  98                                 continue
  99                         indx = ln.index('=')
 100                         if (ln[indx + 1] == 'y'):
 101                                 rtn[ln[7:indx]] = True
 102                         else:
 103                                 rtn[ln[7:indx]] = True
 104         return rtn
 105
 106 def __calchash__(file):
 107         """Calculates hash from configuration file"""
 108         # Build hashconfigsort
 109         csort = []
 110         try:
 111                 with open(conf.hashconfigsort, 'r') as f:
 112                         for ln in f:
 113                                 csort.append(ln.rstrip())
 114         except FileNotFoundError:
 115                 pass
 116
 117         con = __load_config_file__(file)
 118         cstr = ""
 119         for c in csort:
 120                 try:
 121                         if con[c]:
 122                                 cstr += '+'
 123                         else:
 124                                 cstr += '-'
 125                 except ValueError:
 126                         cstr += '0'
 127
 128         # Add missing
 129         csortfile = open(sf(conf.hashconfigsort), 'a');
 130         for key, val in con.items():
 131                 try:
 132                         csort.index(key)
 133                 except ValueError:
 134                         indx = len(csort)
 135                         csort.append(key)
 136                         csortfile.write(key + '\n')
 137                         if val:
 138                                 cstr += '+'
 139                         else:
 140                                 cstr += '-'
 141         csortfile.close()
 142
 143         hsh = hashlib.md5(bytes(cstr, 'UTF-8'))
 144         return hsh.hexdigest()
 145
 146 def __register_conf__(con, conf_num):
 147         dtb = database.database()
 148         # Solution to configuration
 149         wfile = __write_temp_config_file__(con, conf_num)
 150         hsh = __calchash__(wfile)
 151         filen = os.path.join(sf(conf.configurations_folder), hsh)
 152         hshf = hsh
 153         if os.path.isfile(filen):
 154                 if compare(filen, wfile):
 155                         print("I: Generated existing configuration.")
 156                 else:
 157                         print("W: Generated configuration with collision hash.")
 158                         # TODO this might have to be tweaked
 159                         raise Exception()
 160         shutil.move(wfile, filen)
 161         dtb.add_configuration(hsh, hshf)
 162
 163 def __generate_single__(var_num, conf_num):
 164         if os.path.isfile(sf(conf.single_generated_file)):
 165                 return False
 166         measure_list = []
 167         with open(sf(conf.measure_file), 'r') as f:
 168                 for ln in f:
 169                         measure_list.append(int(ln))
 170         for measure in measure_list:
 171                 tfile = __buildtempcnf__(var_num, (sf(conf.rules_file),
 172                         sf(conf.fixed_file)), (str(measure)))
 173                 try:
 174                         confs = __exec_sat__(tfile, ['-i', '0'])
 175                         for con in confs:
 176                                 __register_conf__(con, conf_num)
 177                 except exceptions.NoSolution:
 178                         pass
 179                 finally:
 180                         os.remove(tfile)
 181         with open(sf(conf.single_generated_file), 'w') as f:
 182                 f.write("This file informs scripts, that all single selected configurations are already generated.\n")
 183                 f.write("Remove this file if you want run generating process again.")
 184                 return True
 185
 186 def __generate_random__(var_num, conf_num):
 187         # TODO
 188         pass
 189
 190 def generate():
 191         """Collect boolean equations from files rules and required
 192         And get solution with picosat
 193         """
 194         # Check if rules_file exist. If it was generated.
 195         if not os.path.isfile(sf(conf.rules_file)):
 196                 raise exceptions.MissingFile(conf.rules_file,"Run parse_kconfig.")
 197         if not os.path.isfile(sf(conf.fixed_file)):
 198                 raise exceptions.MissingFile(conf.required_file,"Run allconfig and initialization process.")
 199
 200         # Load variable count
 201         with open(sf(conf.variable_count_file)) as f:
 202                 var_num = f.readline()
 203                 conf_num = f.readline()
 204
 205         if __generate_single__(var_num, conf_num):
 206                 return
 207
 208         #tfile = __buildtempcnf__(var_num, (sf(conf.rules_file), sf(conf.fixed_file)), ())
 209         #try:
 210                 #confs = __exec_sat__(tfile, [])
 211                 #for con in confs:
 212                         #__register_conf__(con, conf_num)
 213         #finally:
 214                 #os.remove(tfile)
 215
 216 def compare(file1, file2):
 217         """Compared two configuration"""
 218         conf1 = __load_config_file__(file1)
 219         conf2 = __load_config_file__(file2)
 220
 221         # This is not exactly best comparison method
 222         for key, val in conf1.items():
 223                 try:
 224                         if conf2[key] != val:
 225                                 return False
 226                 except ValueError:
 227                         return False
 228         for key, val in conf2.items():
 229                 try:
 230                         if conf1[key] != val:
 231                                 return False
 232                 except ValueError:
 233                         return False
 234         return True