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 json

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

# ============================================================================
def process(i):
    """
    Run collective tuning pipeline

    Input:  {
              space                 - available points in space
              pipeline_input        - pipeline input
              pipeline_output       - pipeline output
              desc                  - state description
              tune_characteristics  - list of characteristics to tune 
                                      (priorities, such as global execution time; code size; energy; compilation time, etc -
                                       depending on user scenario)
              calcluate_improvement_over_ref - if !='', use this as the key in space
                                                       to calcluate improvements over first point
              max_improvement_threshold - if at least one of the max improvement more than threshold, add

            }

    Output: {
              cm_return   - if =0, success
              state       - final state
              space       - (updated) space
              must_add    - if 'yes', should add this point
            }
    """

    cior=i.get('calcluate_improvement_over_ref','')

    mit=i.get('max_improvement_threshold','')
    if mit=='': mit='1.0'
    dmit=float(mit)

    space=i.get('space',{})
    pipeline_input=i.get('pipeline_input',{})
    pipeline_output=i.get('pipeline_output',{})
    desc=i.get('desc',{})
    tc=i.get('tune_characteristics',[])
    tc1=tc
    if len(tc)==0: 
       for q in desc:
           if desc[q].get('characteristic','')=='yes':
              tc1.append(q)

    state=pipeline_output.get('state',{})

    cm_kernel.print_for_con('')
    cm_kernel.print_for_con('********************* Performing analysis, filtering and pruning of profitable cases ...')

    if 'points' not in space: space['points']=[]
    points=space['points']

    # current point
    state=pipeline_output.get('state',{})

    cm_kernel.print_for_con('Number of all points: '+str(len(points)))
    cm_kernel.print_for_con('')

    # find if improves any given point on one dimension without making it worse on other
    cm_kernel.print_for_con('')

    td=[] # to delete

    im_0={}

    add=True
    for px1 in range(0, len(points)):
        p1=points[px1]
        state1=p1.get('pipeline_output',{}).get('state',{})

        cm_kernel.print_for_con('')
        cm_kernel.print_for_con('Analyzing solution: '+str(px1)+' of '+str(len(points)-1)+ ' ...')

        found_better=False
        found_worse=False
        for q in tc1:
            v=desc[q]

            cm_kernel.print_for_con('  Processing characteristic '+q+' ...')

            t=v.get('type','')

            rg=cm_kernel.get_value_by_flattened_key({'cm_array':state, 'cm_key':q})
            if rg['cm_return']>0: return rg
            vv=rg['cm_value']

            if vv!=None and vv!='' and (t=='integer' or t=='float'):

               if t=='integer': dv=int(vv)
               elif t=='float': dv=float(vv)

               rg=cm_kernel.get_value_by_flattened_key({'cm_array':state1, 'cm_key':q})
               if rg['cm_return']>0: return rg
               vv1=rg['cm_value']

               if vv1!=None and vv1!='' and (t=='integer' or t=='float'):

                  if t=='integer':  dv1=int(vv1)
                  elif t=='float':  dv1=float(vv1)

                  print '            ',px1, '  ', dv,'  ', dv1

                  if dv<dv1: 
                     found_better=True
                  elif dv>dv1:
                     found_worse=True

                  # If calculating improvement over first point is turned on:
                  if cior!='':
                     if px1==0:
                        im_0[q]=dv1

                     if found_better:
                        if cior not in space: 
                           space[cior]={}

                        if q not in space[cior] or space[cior].get(q,'')=='':
                           space[cior][q]='1.0'

                        cur_im=float(space[cior][q])

                        if im_0[q]!=0 and dv!=0:
                           im=im_0[q]/dv
                           if im>cur_im: 
                              space[cior][q]="%.3f" % im

        if not found_better: add=False

        if not found_worse:
           cm_kernel.print_for_con('')
           cm_kernel.print_for_con('      new solution improved analyzed one - mark for deletion')
           td.append(px1)

    # pruning
    if len(td)>0:
       cm_kernel.print_for_con('')
       cm_kernel.print_for_con(' Pruning the following solutions: '+str(sorted(td)))
       for q in sorted(td, reverse=True):
           if space['points'][q].get('always_keep_this_point','')!='yes':
              del(space['points'][q])

    # Check threshold
    if cior!='' and dmit>1 and add:
       add=False

       # If at least one dimension is more than a threshold, add
       for q in space.get(cior,{}):
           if float(space[cior][q])>dmit:
              add=True
              break

    return {'cm_return':0, 'state':state, 'space':space, 'must_add':add}