module.py

Go to the documentation of this file.

#
# Collective Mind
#
# See cM LICENSE.txt for licensing details.
# See cM Copyright.txt for copyright details.
#
# Developer(s): (C) Grigori Fursin, started on 2011.09
#

# Should always be here
ini={}
cm_kernel=None

# Local settings
import csv
import os
import io
import copy
import base64
import codecs

# ============================================================================
def init(i):
    return {'cm_return':0}

# ============================================================================
def detect(i):

    """
    Detect system properties

    Input:  {
              (host_os_uoa)                     - host OS on which cM is running to detect which scripts to use for detection. 
                                                  If not set, the default one is taken from cM configuration.

              (target_os_uoa)                   - target OS to detect. If =='', host OS is used
    
              (get_uoa_from_repo)               - if 'yes', check if already in repo and return UOA

              (detect_repo_uoa)                 - search entries in this repository (if not set, do not search),
                                                    if not found, add entries

              (record_if_doesnt_exist)          - if 'yes', record in repo if doesn't exist

              (ask_for_strings_if_not_detected) - if 'yes' and strings are not detected, ask for them

              (add_all)                         - if 'yes' add all information including generated files about system
                                                  (used in private setups to keep all information for debugging
                                                   or machine learning (to improve models and find appropriate features))
            }

    Output: {
              cm_return           - return code = 0, if successful

              cm_array            - {
                                      processor_string
                                      system_string
                                      available_physical_memory
                                    }

              processor_string       - processor
              os_string              - OS
              system_string          - System
              memory_string          - All memory
              all_frequencies_string - All possible frequencies


              processor_uoa       - detected processor UOA or taken from the input
              os_uoa              - detected OS UOA or taken from the input
              system_uoa          - prepared system UOA
            }
    """

    # Check some vars
    processor_uoa=i.get('processor_uoa','')
    processor_string=''
    os_uoa=i.get('os_uoa','')
    os_string=''
    system_uoa=i.get('system_uoa','')
    ignore_system=i.get('ignore_system','')
    system_type_uoa=i.get('system_type_uoa','')
    system_type_string=''
    system_provider_uoa=i.get('system_provider_uoa','')
    system_provider_string=''
    system_name=i.get('system_name','')
    system_string=''
    system_manufacturer=''
    available_physical_memory=''
    cpu_freqs_all=''
    cpu_freq_cur=''

    cm_array={}

    rr={'cm_return':0}

    # Check host OS
    host_os_uoa=''
    if i.get('host_os_uoa','')!='':
       host_os_uoa=i['host_os_uoa']
    elif 'cm_default_os_uoa' in cm_kernel.ini['dcfg'] and cm_kernel.ini['dcfg']['cm_default_os_uoa']!='':
       host_os_uoa=cm_kernel.ini['dcfg']['cm_default_os_uoa']

    if host_os_uoa=='' not in i:
       return {'cm_return':1, 'cm_error':'"host_os_uoa" is not defined and not in kernel'}

    cm_kernel.print_for_con('')
    cm_kernel.print_for_con('Loading host os ('+host_os_uoa+') ...')
    ii={'cm_run_module_uoa':ini['cfg']['cm_modules']['os'],
        'cm_action':'load',
        'cm_data_uoa':host_os_uoa}
    r=cm_kernel.access(ii)
    if r['cm_return']>0: return r

    host_os_cfg=r['cm_data_obj']['cfg']
    host_os_path=r['cm_path']
    host_os_uid=r['cm_uid']
    host_os_alias=r['cm_alias']

    # Check target OS
    target_os_uoa=''
    if i.get('target_os_uoa','')!='': target_os_uoa=i['target_os_uoa']
    else: target_os_uoa=host_os_uid

    cm_kernel.print_for_con('')
    cm_kernel.print_for_con('Loading target os ('+target_os_uoa+') ...')
    ii={'cm_run_module_uoa':ini['cfg']['cm_modules']['os'],
        'cm_action':'load',
        'cm_data_uoa':target_os_uoa}
    r=cm_kernel.access(ii)
    if r['cm_return']>0: return r

    target_os_cfg=r['cm_data_obj']['cfg']
    target_os_path=r['cm_path']
    target_os_uid=r['cm_uid']
    target_os_alias=r['cm_alias']

    # Generate tmp file
    r=cm_kernel.gen_cm_tmp_file({})
    if r['cm_return']>0: return r
    tf=r['cm_path']
    tf1=r['cm_path1']
    tff={}

    if target_os_cfg.get('remote','')=='yes': tf1=os.path.basename(tf1)

    # Prepare files depending on OS
    if ini['cfg']['cm_data']['os_classes']['windows'] in target_os_cfg.get('cm_classes_uoa',[]) or \
       ini['cfg']['cm_data']['os_classes']['windows_mingw'] in target_os_cfg.get('cm_classes_uoa',[]):
      tff['sysinfo']=tf1+'.systeminfo.csv'
      tff['proc']=tf1+'.processor.reg'
    else:
      tff['cpu']=tf1+'.cpuinfo.txt'
      tff['cpu.freq.all']=tf1+'.cpu.freq.all.txt'
      tff['cpu.freq.cur']=tf1+'.cpu.freq.cur.txt'
      tff['os']=tf1+'.version.txt'
      tff['mem']=tf1+'.meminfo.txt'
      tff['sys']=tf1+'.system_build_prop.txt'
      tff['dmesg']=tf1+'.dmesg.txt'

    # Prepare files depending on OS
    for q in tff:
        if os.path.isfile(q): os.remove(q)

    # Run system detection script
    cm_kernel.print_for_con('')
    cm_kernel.print_for_con('Execute script')
    cm_kernel.print_for_con('')

    ii={'cm_run_module_uoa':ini['cfg']['cm_modules']['code'],
        'cm_action':'run',
        'run_host_os_uoa':host_os_uid,
        'run_target_os_uoa':target_os_uid,
        'run_script':ini['cfg']['cm_data']['run_script_name'],
        'run_script_uoa':ini['cfg']['cm_data']['run_script_uoa'],
        'run_set_env2':{'SYS_OUT_FILE':tf1},
        'calming_delay':''}
    work_dir=cm_kernel.ini[cm_kernel.env_cm_tmp]
    if work_dir!='': ii['work_dir']=work_dir
    if target_os_cfg.get('remote','')=='yes': 
       ii['run_output_files']=[]
       for q in tff: 
           if tff[q] not in ii['run_output_files']: ii['run_output_files'].append(tff[q])
    r=cm_kernel.access(ii)
    if r['cm_return']>0: return r

    system={}

    s_sys=''
    s_cpu=''
    s_os=''
    cpu_freq_all=[]

    # Check file(s) depending on OS
    if ini['cfg']['cm_data']['os_classes']['windows'] in target_os_cfg.get('cm_classes_uoa',[]) or \
       ini['cfg']['cm_data']['os_classes']['windows_mingw'] in target_os_cfg.get('cm_classes_uoa',[]):
       if os.path.isfile(tff['sysinfo']):
          cm_kernel.print_for_con('')
          cm_kernel.print_for_con('Processing output (Windows)')

          # Read system info
          f=open(tff['sysinfo'], 'rt')
          while True:
              line = f.readline()
              if not line: break
              s_sys+=line.replace(chr(255),',')
          f.close()

          f=open(tff['sysinfo'], 'rb')
          c=csv.reader(f, delimiter=',')

          l=[]
          for q in c:
              l.append(q)

          os_name=''
          os_version=''
          if len(l)>0:
             for q in range(0, len(l[0])):
                 if l[0][q].lower()=='os name': os_name=l[1][q].strip()
                 elif l[0][q].lower()=='os version': os_version=l[1][q].strip()
                 elif l[0][q].lower()=='system manufacturer': system_manufacturer=l[1][q].strip()
                 elif l[0][q].lower()=='system model': system_model=l[1][q].strip()
                 elif l[0][q].lower()=='available physical memory': available_physical_memory=l[1][q].strip().replace(chr(255),'')

          f.close()

          if system_manufacturer!='' and system_model!='': system_string=system_manufacturer+' '+system_model

          if os_name!='' and os_version!='': os_string=os_name+' '+os_version

          # Scan processor
          f=io.open(tff['proc'], 'r', encoding='utf-16')
          while True:
              line = f.readline()
              if not line: break
              line=line.strip('\r\n')
              x='"ProcessorNameString"='
              if line.startswith(x):
                 processor_string=line[len(x):].strip('"')
          f.close()

          os.remove(tff['sysinfo'])
          os.remove(tff['proc'])
       else:
          cm_kernel.print_for_con('')
          cm_kernel.print_for_con('Output files not found!')
  
    else:
       if os.path.isfile(tff['cpu']) or os.path.isfile(tff['os']) or os.path.isfile(tff['mem']):
          cm_kernel.print_for_con('')
          cm_kernel.print_for_con('Processing output (Unix)')

          # Process cpu file
          if os.path.isfile(tff['cpu']):
             f=open(tff['cpu'], 'rt')
             while True:
                 line = f.readline()
                 if not line: break
                 s_cpu+=line
                 line=line.strip('\r\n ')
                 q=line.find(':')
                 if q!=0:
                    k=line[0:q].strip('\r\n\t ')
                    v=line[q+1:].strip(' ')
                    if k=='Processor' and len(v)>2: processor=v
                    if k=='model name': processor_string=v
             f.close()

             if processor_string=='' and processor!='': processor_string=processor

             os.remove(tff['cpu'])

          # Process all freq
          if os.path.isfile(tff['cpu.freq.all']):
             f=open(tff['cpu.freq.all'], 'rt')
             line = f.readline().strip('\r\n\t ')
             f.close()

             cpu_freqs_all=line
             cpu_freq_all=line.split()

             os.remove(tff['cpu.freq.all'])

          # Process cur freq
          if os.path.isfile(tff['cpu.freq.cur']):
             f=open(tff['cpu.freq.cur'], 'rt')
             line = f.readline().strip('\r\n\t ')
             f.close()

             cpu_freq_cur=line

             os.remove(tff['cpu.freq.cur'])

          # Process OS file
          if os.path.isfile(tff['os']):

             f=open(tff['os'], 'rt')
             line = f.readline()
             s_os=line.strip('\r\n ')
             f.close()

             if s_os!='': os_string=s_os

             os.remove(tff['os'])

          # Process memory file
          if os.path.isfile(tff['mem']):

             mem_total=''
             f=open(tff['mem'], 'rt')
             while True:
                 line = f.readline()
                 if not line: break
                 line=line.strip('\r\n ')
                 q=line.find(':')
                 if q!=0:
                    k=line[0:q].strip('\r\n\t ').lower()
                    v=line[q+1:].strip(' ')
                    if k=='memtotal' and len(v)>0: mem_total=v
             f.close()

             os.remove(tff['mem'])

             if mem_total!='':
                mem=mem_total.split(' ', 1);
                if len(mem)>0:
                   mem1=mem[0]
                   mem2='1'
                   if len(mem1)>3:
                      mem2=mem1[:-3]

                   available_physical_memory=mem2+' MB'

          # Process system file
          if os.path.isfile(tff['sys']):

             manufacturer=''
             product_name=''

             f=open(tff['sys'], 'rt')
             while True:
                 line = f.readline()
                 if not line: break
                 line=line.strip('\r\n ')
                 q=line.find('=')
                 if q!=0:
                    k=line[0:q].strip('\r\n\t ').lower()
                    v=line[q+1:].strip(' ')
                    if k=='ro.product.manufacturer' and len(v)>0: manufacturer=v
                    elif k=='ro.product.name' and len(v)>0: product_name=v
                    elif k=='ro.build.product' and len(v)>0: 
                         if product_name=='': 
                            product_name=v
             f.close()

             os.remove(tff['sys'])

             if manufacturer!='' and product_name!='':
                system_string=manufacturer[0].upper()+manufacturer[1:]+' '+product_name

          # Process system file
          if system_string=='' and os.path.isfile(tff['dmesg']):

             dmi=''

             f=open(tff['dmesg'], 'rt')
             while True:
                 line = f.readline()
                 if not line: break
                 line=line.strip('\r\n ')
                 q=line.lower().find(' dmi: ')
                 if q>0:
                    dmi=line[q+5:].strip(' ')
                    break
             f.close()

             os.remove(tff['dmesg'])

             if dmi!='':
                q1=dmi.find('  ')
                if q1>0: dmi=dmi[:q1].strip()

             if dmi!='':
                q1=dmi.lower().find(', bios')
                if q1>0: dmi=dmi[:q1].strip()

             if dmi!='':
                q1=dmi.lower().find('/')
                if q1>0: dmi=dmi[:q1].strip()

             if dmi!='':
                system_string=dmi

    # Ask if system was not automatically detected
    if system_string=='' and i.get('ask_for_strings_if_not_detected','')=='yes':
       cm_kernel.print_for_con('')
       cm_kernel.print_for_con('System string was not automatically detected!')

       cm_kernel.print_for_con('')
       system_string=raw_input('Enter system description in a format "<Manufacturer> <System name>": ')

       system_string=system_string.strip()

    if os_string=='' and i.get('ask_for_strings_if_not_detected','')=='yes':
       cm_kernel.print_for_con('')
       cm_kernel.print_for_con('OS string was not automatically detected!')

       cm_kernel.print_for_con('')
       os_string=raw_input('Enter OS description: ')

       os_string=os_string.strip()

    if available_physical_memory=='' and i.get('ask_for_strings_if_not_detected','')=='yes':
       cm_kernel.print_for_con('')
       cm_kernel.print_for_con('Memory string was not automatically detected!')

       cm_kernel.print_for_con('')
       available_physical_memory=raw_input('Enter memory description: ')

       available_physical_memory=available_physical_memory.strip()

    # Finalizing system detection

    processor_string=processor_string.replace(unichr(255),',')
    processor_string=" ".join(processor_string.split())

    cm_array['processor_string']=processor_string
    cm_array['system_string']=system_string
    cm_array['available_physical_memory']=available_physical_memory

    rr['cm_array']=cm_array
    rr['processor_string']=processor_string
    rr['os_string']=os_string
    rr['system_string']=system_string
    rr['memory_string']=available_physical_memory
    rr['all_frequencies_string']=cpu_freqs_all

    cm_kernel.print_for_con('')
    cm_kernel.print_for_con('Processor string: '+processor_string)
    cm_kernel.print_for_con('   Memory string: '+available_physical_memory)
    cm_kernel.print_for_con('       OS string: '+os_string)
    cm_kernel.print_for_con('   System string: '+system_string)
    cm_kernel.print_for_con('')
    cm_kernel.print_for_con(' All frequencies: '+cpu_freqs_all)
    cm_kernel.print_for_con('  Cur. frequency: '+cpu_freq_cur)

    if i.get('get_uoa_from_repo','')!='yes': 
       return rr

    # Check in the repository
    repo=i.get('detect_repo_uoa','')
    if repo=='':
       return {'cm_return':1, 'cm_error':'repository is not defined'}

    record=i.get('record_if_doesnt_exist','')
    notes=i.get('notes','')

    # Check/add processor *****************************************************************
    if processor_string!='':

       cm_kernel.print_for_con('')
       cm_kernel.print_for_con('Searching processor "'+processor_string+'" in the repository ...')

       ii={'cm_run_module_uoa':ini['cfg']['cm_modules']['cm-core'],
           'cm_action':'search',
           'key_0':'##cm_properties#processor_string',
           'value_0':processor_string,
           'use_flat_array':'yes',
           'module_selection':[ini['cfg']['cm_modules']['ctuning.processor']]
          }
       if repo!='': ii['repo_selection']=[repo]
       r=cm_kernel.access(ii)
       if r['cm_return']>0: return r

       all=r['all']

       if len(all)==0:
          cm_kernel.print_for_con('')
          cm_kernel.print_for_con('Processor not found in the repository!')

          # Prepare to add
          jj={'cm_run_module_uoa':ini['cfg']['cm_modules']['ctuning.processor'],
              'cm_action':'add',
              'cm_array':{'cm_properties':{'processor_string':processor_string, 'cpu_frequency_all':cpu_freq_all}},
              'cm_display_as_alias':processor_string,
              'cm_repo_uoa':repo,
              'cm_note':notes
             }

          if i.get('add_all','')=='yes':
             if s_cpu!='':
                jj['cm_file_upload']=s_cpu
                jj['cm_file_upload_name']='cpuinfo.txt'
             elif s_sys!='':
                jj['cm_file_upload_base64']=base64.urlsafe_b64encode(s_sys)
                jj['cm_file_upload_name']='systeminfo.csv'

          r=cm_kernel.access(jj)
          if r['cm_return']>0: return r

          processor_uoa=r['cm_uid']

          cm_kernel.print_for_con('')
          cm_kernel.print_for_con('Processor entry added: '+processor_uoa)

       else:
          processor_uoa=all[0]['cm_data_uoa']

          cm_kernel.print_for_con('')
          cm_kernel.print_for_con('Processor entry found: '+processor_uoa)

    # Check/add OS *****************************************************************
    if os_string!='':

       cm_kernel.print_for_con('')
       cm_kernel.print_for_con('Searching OS "'+os_string+'" in the repository ...')

       ii={'cm_run_module_uoa':ini['cfg']['cm_modules']['cm-core'],
           'cm_action':'search',
           'key_0':'##cm_properties#os_string',
           'value_0':os_string,
           'use_flat_array':'yes',
           'module_selection':[ini['cfg']['cm_modules']['ctuning.os']],
           'cm_repo_uoa':repo
          }
       r=cm_kernel.access(ii)
       if r['cm_return']>0: return r

       all=r['all']

       if len(all)==0:
          cm_kernel.print_for_con('')
          cm_kernel.print_for_con('OS not found in the repository!')

          # Prepare to add
          jj={'cm_run_module_uoa':ini['cfg']['cm_modules']['ctuning.os'],
              'cm_action':'add',
              'cm_array':{'cm_properties':{'os_string':os_string}},
              'cm_display_as_alias':os_string,
              'cm_repo_uoa':repo,
              'cm_note':notes
             }

          r=cm_kernel.access(jj)
          if r['cm_return']>0: return r

          os_uoa=r['cm_uid']

          cm_kernel.print_for_con('')
          cm_kernel.print_for_con('OS entry added: '+os_uoa)
       else:
          os_uoa=all[0]['cm_data_uoa']

          cm_kernel.print_for_con('')
          cm_kernel.print_for_con('OS entry found: '+os_uoa)

    # Check/add system *****************************************************************
    if system_string!='':

       cm_kernel.print_for_con('')
       cm_kernel.print_for_con('Searching System "'+system_string+'" in the repository ...')

       ii={'cm_run_module_uoa':ini['cfg']['cm_modules']['cm-core'],
           'cm_action':'search',
           'key_0':'##cm_properties#system_string',
           'value_0':system_string,
           'use_flat_array':'yes',
           'module_selection':[ini['cfg']['cm_modules']['ctuning.system']],
           'cm_repo_uoa':repo
          }
       r=cm_kernel.access(ii)
       if r['cm_return']>0: return r

       all=r['all']

       if len(all)==0:
          cm_kernel.print_for_con('')
          cm_kernel.print_for_con('System not found in the repository!')

          # Prepare to add
          jj={'cm_run_module_uoa':ini['cfg']['cm_modules']['ctuning.system'],
              'cm_action':'add',
              'cm_array':{'cm_properties':{'system_string':system_string}, 
                          'cm_misc_info':cm_array},
              'cm_display_as_alias':system_string,
              'cm_repo_uoa':repo,
              'cm_note':notes
             }

          if system_type_uoa!='':
             jj['cm_array']['system_type_uoa']=system_type_uoa

          r=cm_kernel.access(jj)
          if r['cm_return']>0: return r

          system_uoa=r['cm_uid']

          cm_kernel.print_for_con('')
          cm_kernel.print_for_con('System entry added: '+system_uoa)
       else:
          system_uoa=all[0]['cm_data_uoa']

          cm_kernel.print_for_con('')
          cm_kernel.print_for_con('System entry found: '+system_uoa)


    cm_kernel.print_for_con('')
    cm_kernel.print_for_con('Detection finished!')

    rr['cm_return']=0

    rr['processor_uoa']=processor_uoa
    rr['os_uoa']=os_uoa
    rr['system_uoa']=system_uoa

    return rr

# ============================================================================
def web_detect(i):

    """
    Detect system properties through Web

    Input:  See detect(i)
    Output: See detect(i)

    """

    # Get web style
    if 'cfg' in cm_kernel.ini['web_style']: web=cm_kernel.ini['web_style']['cfg']
    else:
       return {'cm_return':1, 'cm_error':'web style is not defined'}

    cm_kernel.print_for_con('<span class="cm-title">Prepare/detect system for collective tuning</span><br>')

    # Detecting/restoring data from forms
    a1={}
    r=cm_kernel.access({'cm_run_module_uoa':ini['cfg']['cm_modules']['cm-web'],
                        'cm_action':'detect_form_params',
                        'cm_array':i, 
                        'cm_prefix':'#form1'})
    if r['cm_return']>0: return r
    cm_form_array1=r['cm_array']
    cm_form_commands1=r['cm_commands']

    # Get data description for this action
    r=cm_kernel.get_data_description({'cm_module_uoa':ini['cm_module_uoa'], 
                                      'cm_which_action':i['cm_action']})
    if r['cm_return']>0: return r
    cm_data_desc1=r['cm_data_desc']
    cm_params_default1=r['cm_params_default']

    # Check default
    forms_exists='yes'
    if len(cm_form_array1)==0:
       a1=cm_params_default1

       forms_exists='no'
    else:
       r=cm_kernel.restore_flattened_array({'cm_array':cm_form_array1, 
                                            'cm_replace_in_keys':{'^35^':'#', '^64^':'@'}})
       if r['cm_return']>0: return r
       a1=r['cm_array']

    # Check if start detection
    if 'cm_submit_detect' in i:
       ii={}
       ii['cm_run_module_uoa']=ini['cm_module_uid']
       ii['cm_action']='detect'
       ii['cm_detach_console']='yes'
       ii.update(a1)
       r=cm_kernel.access_fe_through_cmd(ii)
       if r['cm_return']>0: return r

       del(i['cm_submit_detect'])

    # This table is used to show json in the right corner
    cm_kernel.print_for_con('<br><table border="0"><tr>')

    cm_kernel.print_for_con('<td align="center">')
    cm_kernel.print_for_con('<FORM ACTION="" name="add_edit" METHOD="POST" enctype="multipart/form-data" accept-charset="utf-8">' )

    ii={'cm_run_module_uoa':ini['cfg']['cm_modules']['cm-web'],
        'cm_action':'visualize_data',
        'cm_array':a1,
        'cm_data_desc':cm_data_desc1,
        'cm_form_commands':cm_form_commands1,
        'cm_separator':'#',
        'cm_separator_form':'#form1#',
        'cm_forms_exists':forms_exists,
        'cm_support_raw_edit':'no',
        'cm_mode':'add'}
    if 'cm_raw_edit' in i: ii['cm_raw_edit']=i['cm_raw_edit']
    if 'cm_back_json' in i: ii['cm_back_json']=i['cm_back_json']
    r=cm_kernel.access(ii)
    if r['cm_return']>0: return r
    cm_kernel.print_for_web(r['cm_string'])

    cm_kernel.print_for_con('<input type="submit" class="cm-button" name="cm_submit_detect" value="Detect / add">')

    cm_kernel.print_for_con('<input type="submit" class="cm-button" value="Refresh">')

    cm_kernel.print_for_con('</FORM><br>')
    cm_kernel.print_for_con('</td>')
    cm_kernel.print_for_con('<td valign="TOP">')
 
    # Debug/developer mode
    if a1.get('cm_show_json','')=='yes':
       cm_kernel.print_for_web('<div class="cm-round-div">')
       cm_kernel.print_for_con('<i><B><small>JSON to reproduce last command</small></B></i>')
       cm_kernel.print_for_con('<HR class="cm-hr">')

       cm_kernel.print_for_web(json.dumps(last_command, indent=2).replace('\n','\n<BR>\n'))

       cm_kernel.print_for_con('<HR class="cm-hr">')
       cm_kernel.print_for_con('<b>Envoke command from CMD:</b><BR>')
       cm_kernel.print_for_con('<i>cm '+last_command.get('cm_run_module_uoa')+' @input.json</i>')

       cm_kernel.print_for_web('</div>')

    cm_kernel.print_for_con('</td></tr></table>')

    return {'cm_return':0}


# ============================================================================
def get_state(i):

    """
    Get current state

    Input:  {
              (host_os_uoa)        - host OS on which cM is running to detect which scripts to use for detection. 
                                     If not set, the default one is taken from cM configuration.

              (target_os_uoa)      - target OS to detect. If =='', host OS is used
            }

    Output: {
              cm_return - return code = 0, if successful

              system_state         - [windows]
                                     [unix]
            }
    """

    # Check host OS
    host_os_uoa=''
    if i.get('host_os_uoa','')!='':
       host_os_uoa=i['host_os_uoa']
    elif 'cm_default_os_uoa' in cm_kernel.ini['dcfg'] and cm_kernel.ini['dcfg']['cm_default_os_uoa']!='':
       host_os_uoa=cm_kernel.ini['dcfg']['cm_default_os_uoa']

    if host_os_uoa=='' not in i:
       return {'cm_return':1, 'cm_error':'"host_os_uoa" is not defined and not in kernel'}

    cm_kernel.print_for_con('')
    cm_kernel.print_for_con('Loading host os ('+host_os_uoa+') ...')
    ii={'cm_run_module_uoa':ini['cfg']['cm_modules']['os'],
        'cm_action':'load',
        'cm_data_uoa':host_os_uoa}
    r=cm_kernel.access(ii)
    if r['cm_return']>0: return r

    host_os_cfg=r['cm_data_obj']['cfg']
    host_os_path=r['cm_path']
    host_os_uid=r['cm_uid']
    host_os_alias=r['cm_alias']

    # Check target OS
    target_os_uoa=''
    if i.get('target_os_uoa','')!='': target_os_uoa=i['target_os_uoa']
    else: target_os_uoa=host_os_uid

    cm_kernel.print_for_con('')
    cm_kernel.print_for_con('Loading target os ('+target_os_uoa+') ...')
    ii={'cm_run_module_uoa':ini['cfg']['cm_modules']['os'],
        'cm_action':'load',
        'cm_data_uoa':target_os_uoa}
    r=cm_kernel.access(ii)
    if r['cm_return']>0: return r

    target_os_cfg=r['cm_data_obj']['cfg']
    target_os_path=r['cm_path']
    target_os_uid=r['cm_uid']
    target_os_alias=r['cm_alias']

    # Generate tmp file
    r=cm_kernel.gen_cm_tmp_file({})
    if r['cm_return']>0: return r
    tf=r['cm_path']
    tf1=r['cm_path1']
    tff={}

    if target_os_cfg.get('remote','')=='yes': tf1=os.path.basename(tf1)

    # Prepare files depending on OS
    if ini['cfg']['cm_data']['os_classes']['windows'] in target_os_cfg.get('cm_classes_uoa',[]):
      tff['cpu']=tf1+'.cpu.txt'
    else:
      tff['cpu.info']=tf1+'.cpu.info.txt'
      tff['cpu.freq.all']=tf1+'.cpu.freq.all.txt'
      tff['cpu.freq.cur']=tf1+'.cpu.freq.cur.txt'

    # Run system state detection script
    cm_kernel.print_for_con('')
    cm_kernel.print_for_con('Execute script')
    cm_kernel.print_for_con('')

    ii={'cm_run_module_uoa':ini['cfg']['cm_modules']['code'],
        'cm_action':'run',
        'run_host_os_uoa':host_os_uid,
        'run_target_os_uoa':target_os_uid,
        'run_script':ini['cfg']['cm_data']['run_script_name_get_state'],
        'run_script_uoa':ini['cfg']['cm_data']['run_script_uoa'],
        'run_set_env2':{'SYS_OUT_FILE':tf1},
        'calming_delay':''}
    work_dir=cm_kernel.ini[cm_kernel.env_cm_tmp]
    if work_dir!='': ii['work_dir']=work_dir
    if target_os_cfg.get('remote','')=='yes': 
       ii['run_output_files']=[]
       for q in tff: 
           if tff[q] not in ii['run_output_files']: ii['run_output_files'].append(tff[q])
    r=cm_kernel.access(ii)
    if r['cm_return']>0: return r

    system_state={}
    system_state['properties']={}
    ssp=system_state['properties']

    # Check file(s) depending on OS
    if ini['cfg']['cm_data']['os_classes']['windows'] in target_os_cfg.get('cm_classes_uoa',[]):
       ssp['windows']={}
       ssp['windows']['cpu_state']={}
       ss=ssp['windows']['cpu_state']
       if os.path.isfile(tff['cpu']):
          cm_kernel.print_for_con('')
          cm_kernel.print_for_con('Processing output (Windows)')

          f=codecs.open(tff['cpu'], encoding='utf-16', mode='r')
          line='x'
          while line!='':
              line=f.readline()
              line1=line.strip()
              q=line1.find('=')
              if q>0:
                 k=line1[0:q].strip(' ')
                 v=line1[q+1:].strip(' ')
                 ss[k]=v
          f.close()

          if 'AddressWidth' in ss: ssp['cpu_address_width']=ss['AddressWidth']
          if 'DataWidth' in ss: ssp['cpu_data_width']=ss['DataWidth']
          if 'CurrentClockSpeed' in ss: ssp['cpu_frequency']=str(float(ss['CurrentClockSpeed'])*1000)
          if 'MaxClockSpeed' in ss: ssp['cpu_max_frequency']=str(float(ss['MaxClockSpeed'])*1000)
          if 'L2CacheSize' in ss: ssp['cache_l2_size']=ss['L2CacheSize']
          if 'L3CacheSize' in ss: ssp['cache_l3_size']=ss['L3CacheSize']
          if 'NumberOfCores' in ss: ssp['number_of_cores']=ss['NumberOfCores']
          if 'NumberOfLogicalProcessors' in ss: ssp['number_of_logical_processors']=ss['NumberOfLogicalProcessors']

          os.remove(tff['cpu'])

    else:
       ssp['unix']={}
       ssp['unix']['cpu_state']={}
       ss=ssp['unix']['cpu_state']

       cm_kernel.print_for_con('')
       cm_kernel.print_for_con('Processing output (Unix)')

       # Process cpu file
       if os.path.isfile(tff['cpu.info']):
          f=open(tff['cpu.info'], 'rt')
          while True:
              line = f.readline()
              if not line: break
              line=line.strip('\r\n\t ')
              q=line.find(':')
              if q!=0:
                 k=line[0:q].strip('\r\n\t ')
                 v=line[q+1:].strip('\r\n\t ')
                 ss[k]=v
          f.close()

          os.remove(tff['cpu.info'])

       # Process all freq
       if os.path.isfile(tff['cpu.freq.all']):
          f=open(tff['cpu.freq.all'], 'rt')
          line = f.readline().strip('\r\n\t ')
          f.close()

          ssp['cpu_frequency_all']=line.split()

          os.remove(tff['cpu.freq.all'])

       # Process cur freq
       if os.path.isfile(tff['cpu.freq.cur']):
          f=open(tff['cpu.freq.cur'], 'rt')
          line = f.readline().strip('\r\n\t ')
          f.close()

          ssp['cpu_frequency']=line

          os.remove(tff['cpu.freq.cur'])

    return {'cm_return':0, 'system_state':system_state}

# ============================================================================
def set_cpu_frequency(i):

    """
    Set CPU frequency

    Input:  {
              (host_os_uoa)        - host OS on which cM is running to detect which scripts to use for detection. 
                                     If not set, the default one is taken from cM configuration.

              (target_os_uoa)      - target OS to detect. If =='', host OS is used
              frequency            - frequency
              (use_sudo)           - if 'yes', use SUDO
            }

    Output: {
              cm_return - return code = 0, if successful

              system_state         - [windows]
                                     [unix]
            }
    """

    # Check host OS
    host_os_uoa=''
    if i.get('host_os_uoa','')!='':
       host_os_uoa=i['host_os_uoa']
    elif 'cm_default_os_uoa' in cm_kernel.ini['dcfg'] and cm_kernel.ini['dcfg']['cm_default_os_uoa']!='':
       host_os_uoa=cm_kernel.ini['dcfg']['cm_default_os_uoa']

    if host_os_uoa=='' not in i:
       return {'cm_return':1, 'cm_error':'"host_os_uoa" is not defined and not in kernel'}

    cm_kernel.print_for_con('')
    cm_kernel.print_for_con('Loading host os ('+host_os_uoa+') ...')
    ii={'cm_run_module_uoa':ini['cfg']['cm_modules']['os'],
        'cm_action':'load',
        'cm_data_uoa':host_os_uoa}
    r=cm_kernel.access(ii)
    if r['cm_return']>0: return r

    host_os_cfg=r['cm_data_obj']['cfg']
    host_os_path=r['cm_path']
    host_os_uid=r['cm_uid']
    host_os_alias=r['cm_alias']

    # Check target OS
    target_os_uoa=''
    if i.get('target_os_uoa','')!='': target_os_uoa=i['target_os_uoa']
    else: target_os_uoa=host_os_uid

    cm_kernel.print_for_con('')
    cm_kernel.print_for_con('Loading target os ('+target_os_uoa+') ...')
    ii={'cm_run_module_uoa':ini['cfg']['cm_modules']['os'],
        'cm_action':'load',
        'cm_data_uoa':target_os_uoa}
    r=cm_kernel.access(ii)
    if r['cm_return']>0: return r

    target_os_cfg=r['cm_data_obj']['cfg']
    target_os_path=r['cm_path']
    target_os_uid=r['cm_uid']
    target_os_alias=r['cm_alias']

    # Run script
    cm_kernel.print_for_con('')
    cm_kernel.print_for_con('Execute script')
    cm_kernel.print_for_con('')

    sudo=''
    if i.get('use_sudo','')=='yes': sudo='sudo '

    ii={'cm_run_module_uoa':ini['cfg']['cm_modules']['code'],
        'cm_action':'run',
        'run_host_os_uoa':host_os_uid,
        'run_target_os_uoa':target_os_uid,
        'run_script':ini['cfg']['cm_data']['run_script_name_set_cpu_freq'],
        'run_script_uoa':ini['cfg']['cm_data']['run_script_uoa'],
        'run_set_env2':{'CM_CPU_FREQUENCY':i.get('frequency',''), 
                        'CM_SUDO':sudo},
        'calming_delay':''}
    if target_os_cfg.get('cm_tool_prefix','')!='':
       ii['run_set_env2']['CM_TOOL_PREFIX']=target_os_cfg['cm_tool_prefix']
    r=cm_kernel.access(ii)
    if r['cm_return']>0: return r

    return {'cm_return':0}