micropython

TO_DO.txt

591:32adc6af1dc4
2012-07-10 Paul Boddie Changed true/false value usage, employing boolean values instead of numbers.
     1 Name usage types: as parameters, as base classes, as callables. This potentially restricts
     2 attribute usage effects because names mentioned as base classes are not propagated and
     3 made freely available for use in attribute accesses.
     4 
     5 Low-Level Instructions and Macro Instructions
     6 =============================================
     7 
     8 Have contexts and values stored separately in memory. This involves eliminating DataValue
     9 and storing attributes using two words.
    10 
    11 Migrate macro instructions such as the *Index instructions to library code implemented
    12 using low-level instructions.
    13 
    14 Consider introducing classic machine level instructions (word addition, subtraction, and
    15 so on) in order to implement all current RSVP instructions.
    16 
    17 Move common code sequences to a library routine, such as the context checking that occurs
    18 in functions and methods.
    19 
    20 Dataflow Optimisations
    21 ======================
    22 
    23 Assignments, particularly now that no result register exists, may cause StoreTemp/LoadTemp
    24 instruction pairs to be produced and these could be eliminated.
    25 
    26 Class and Module Attribute Assignment
    27 =====================================
    28 
    29 Allow unrestricted class and module assignment (but not new external binding of
    30 attributes), eliminating run-time checks on object types in instructions like
    31 StoreAttrIndex. This may involve less specific objects being identified during inspection.
    32 
    33   Potentially re-evaluate class bases in order to see if they are non-constant.
    34 
    35 Verify that the context information is correctly set, particularly for the unoptimised
    36 cases.
    37 
    38   Update docs/assignment.txt.
    39 
    40 Prevent assignments within classes, such as method aliasing, from causing the source of an
    41 assignment from being automatically generated. Instead, only external references should be
    42 registered.
    43 
    44 Prevent "from <module> import ..." statements from registering references to such local
    45 aliases such that they cause the source of each alias to be automatically generated.
    46 
    47 Consider attribute assignment observations, along with the possibility of class and module
    48 attribute assignment.
    49 
    50   (Note direct assignments as usual, indirect assignments via the attribute usage
    51   mechanism. During attribute collection and inference, add assigned values to all
    52   inferred targets.)
    53 
    54   (Since class attributes can be assigned, StoreAttrIndex would no longer need to reject
    55   static attributes, although this might still be necessary where attribute usage analysis
    56   has not been performed.)
    57 
    58   Potentially consider changing static attribute details to use object-relative offsets in
    59   order to simplify the instruction implementations. This might allow us to eliminate the
    60   static attribute flag for attributes in the object table, at least at run-time.
    61 
    62 Dynamic Attribute Access
    63 ========================
    64 
    65 Consider explicit accessor initialisation:
    66 
    67   attr = accessor("attr")
    68   getattr(C, attr)
    69 
    70 Attribute Usage
    71 ===============
    72 
    73 To consider: is it useful to distinguish between attribute name sets when the same names
    74 are mentioned, but where one path through the code sets different values on attributes
    75 than another? The _attrtypes collapses observations in order to make a list of object
    76 types for a name, and the final set of names leading to such type deductions might be a
    77 useful annotation to be added alongside _attrcombined.
    78 
    79   Update the reports to group identical sets of attribute names.
    80 
    81 Interface/Type Generalisation
    82 -----------------------------
    83 
    84 Consolidate interface observations by taking all cached table accesses and determining
    85 which usage patterns lead to the same types. For example, if full usage of {a, b} and
    86 {a, b, c} leads to A and B in both cases, either {a, b} can be considered as partial usage
    87 of the complete interface {a, b, c}, or the latter can be considered as an
    88 overspecification of the former.
    89 
    90 Consider type deduction and its consequences where types belong to the same hierarchy
    91 and where a guard could be generated for the most general type.
    92 
    93 Consider permitting multiple class alternatives where the attributes are all identical.
    94 
    95 Support class attribute positioning similar to instance attribute positioning, potentially
    96 (for both) based on usage observations. For example, if __iter__ is used on two classes,
    97 the class attribute could be exposed at a similar relative position to the class (and
    98 potentially accessible using a LoadAttr-style instruction).
    99 
   100 **** Constant attribute users need not maintain usage since they are already resolved. ****
   101 
   102 Self-related Usage
   103 ------------------
   104 
   105 Perform attribute usage on attributes of self as names, potentially combining observations
   106 across methods.
   107 
   108 Additional Guards
   109 -----------------
   110 
   111 Consider handling branches of values within namespaces in order to support more precise value usage.
   112 
   113 Loop entry points and other places where usage becomes more specific might be used as
   114 places to impose guards. See tests/attribute_access_type_restriction_loop_list.py for an
   115 example. (Such information is already shown in the reports.)
   116 
   117 Strict Interfaces/Types
   118 -----------------------
   119 
   120 Make the gathering of usage parameterisable according to the optimisation level so that a
   121 choice can be made between control-flow-dependent observations and the simple collection
   122 of all attributes used with a name (producing a more static interface observation).
   123 
   124 AttributeError
   125 --------------
   126 
   127 Consider attribute usage observations being suspended or optional inside blocks where
   128 AttributeError may be caught (although this doesn't anticipate such exceptions being
   129 caught outside a function altogether). For example:
   130 
   131   y = a.y
   132   try:
   133       z = a.z # z is an optional attribute
   134   except AttributeError:
   135       z = None
   136 
   137 Instantiation Deduction
   138 -----------------------
   139 
   140 Consider handling CallFunc in micropython.inspect in order to produce instances of specific classes.
   141 Then, consider adding support for guard removal/verification where known instances are involved. For
   142 example:
   143 
   144   l = []
   145   l.append(123) # type deductions are filtered using instantiation knowledge
   146 
   147 Frame Optimisations
   148 ===================
   149 
   150 Stack frame replacement where a local frame is unused after a call, such as in a tail call
   151 situation.
   152 
   153 Local assignment detection plus frame re-use. Example: slice.__init__ calls
   154 xrange.__init__ with the same arguments which are unchanged in xrange.__init__. There is
   155 therefore no need to build a new frame for this call, although in some cases the locals
   156 frame might need expanding.
   157 
   158 Reference tracking where objects associated with names are assigned to attributes of other
   159 objects may assist in allocation optimisations. Recording whether an object referenced by
   160 a name is assigned to an attribute, propagated to another name and assigned to an
   161 attribute, or passed to another function or method might, if such observations were
   162 combined, allow frame-based or temporary allocation to occur.
   163 
   164 Instantiation
   165 =============
   166 
   167 Specific instances could be produced, providing type information and acting somewhat like
   168 classes during inspection.
   169 
   170 Inlining
   171 ========
   172 
   173 Where a function or method call can always be determined, the body of the target could be
   174 inlined - copied into place - within the caller. If the target is only ever called by a
   175 single caller it could be moved into place. This could enhance deductions based on
   176 attribute usage since observations from the inlined function would be merged into the
   177 caller.
   178 
   179 Function Specialisation
   180 =======================
   181 
   182 Specialisation of certain functions, such as isinstance(x, cls) where cls is a known
   183 constant.
   184 
   185 Structure and Object Table Optimisations
   186 ========================================
   187 
   188 Fix object table entries for attributes not provided by any known object, or provide an
   189 error, potentially overridden by options. For example, the augmented assignment methods
   190 are not supported by the built-in objects and thus the operator module functions cause
   191 the compilation to fail. Alternatively, just supply the methods since something has to do
   192 so in the builtins.
   193 
   194 Consider attribute merging where many attributes are just aliases for the same underlying
   195 definition.
   196 
   197 Consider references to defaults as occurring only within the context of a particular
   198 function, thus eliminating default value classes if such functions are not themselves
   199 invoked.
   200 
   201 Scope Handling
   202 ==============
   203 
   204 Consider merging the InspectedModule.store tests with the scope conflict handling.
   205 
   206 Consider labelling _scope on assignments and dealing with the assignment of removed
   207 attributes, possibly removing the entire assignment, and distinguishing between such cases
   208 and unknown names.
   209 
   210 Check name origin where multiple branches could yield multiple scope interpretations:
   211 
   212   try:
   213       set # built-in name
   214   except NameError:
   215       from sets import Set as set # local definition of name
   216 
   217   set # could be confused by the local definition at run-time
   218 
   219 Object Coverage
   220 ===============
   221 
   222 Support __init__ traversal (and other implicit names) more effectively.
   223 
   224 Importing Modules
   225 =================
   226 
   227 Consider supporting relative imports, even though this is arguably a misfeature.
   228 
   229 Other
   230 =====
   231 
   232 Consider a separate annotation phase where deductions are added to the AST for the
   233 benefit of both the reporting and code generation phases.
   234 
   235 Check context_value initialisation (avoiding or handling None effectively).
   236 
   237 Consider better "macro" support where new expressions need to be generated and processed.
   238 
   239 Detect TestIdentity results involving constants, potentially optimising status-affected
   240 instructions:
   241 
   242   TestIdentity(x, y) # where x is always y
   243   JumpIfFalse(...)   # would be removed (never false)
   244   JumpIfTrue(...)    # changed to Jump(...)
   245 
   246 Status-affected blocks could be optimised away for such constant-related results.