Copilot/TODO at development · devmjc/Copilot · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
TODOs

* Fix 'XXX's through the code.

* Modify atom so that it refuses names that produce invalid C code. See
   checkname in Language.Atom.Elaboration.hs (still probably bugged) Also see
   normalizeVar in Language.Copilot.Core.hs. (Actually, should Copilot worry
   about it?  It'll just fail during compilation, so there's nothing dangerous
   about it.)

 * Add arrays to the language(?)

 * Do MC/DC coverage testing(?)
   * Use the open-source Certification thing?

 * AIG-based equivalence checking.

 * Add math.h functions to Language.hs.

 * Move all the error-checking to one file, instead of "error ..." spread all
   over.
   get rid of getMaybeElem from the compiler---all error checking should be done
   in Analysis.  Also, all errors.

 * Better error handling/error message for bad options/parameters for interface
   functions.  Perhaps use hsTidy?  <http://hackage.haskell.org/package/hstidy>

 * Use para <http://hackage.haskell.org/package/para> for pretty-formatting
   error msgs from Analyzer.hs as well as Help.hs.

 * Add to Help.hs documentation on using the setClock function to use the HW
   clock.

 * Fix splint warnings on generated C code

 * Libs/Indexes return a parameterized type rather than Int16

 * Display external vars when interpreting

 * Make showing better---don't show with constructors but something more
   user-friendly.  ShowRaw in Core.hs.

 * Generate random arrays?

 * Compare some sample specs to Lustre and Esterel.

 * Try the cast operation in Core.hs.

 * Revisit: why no sampling in phase 0?

 * Move triggers to Compile.hs.

 * Define a clocks library.

 * Lots of debugging with sampling functions (both array and var return types).

 * Add a 'when' operator to the Clocks lib: when clk foo means update foo if clk
   is true.

 * The scheduling is completely unoptimized...  All sampling in phase 1, and all
   next-state computation in phase 0.  Spread out as room permits across phases?
   (Need to add a "beforePhase" to Atom.)

 * Normalize variables just once and then pass those around instead of doing it
   ad-hoc throughout the compiler.

 * Make a constant for the setPP option of ("","") meaning don't try to
   compile/add main.  Do we really want to have an option to set array index
   sizes?  What if we're sampling a function that returns an array?  Also, we
   don't declare functions in general...  We could, but do we want to?

 * Rename options to things more memorable. :)

 * Allow for external variables to be used as function args.  (Not sure if this
   should be done.  Will require some rewiring, and passing "through" Copilot
   vars gives extra typechecking.)

 * Make assignment of input vars easier.  Just give var names and values, and
   look up their type in the Interface to assign the maps.

 * Make the assignment of input vars in compiled testing better.  Fix Help.hs.
   Something like setE-C ("x", "y") and let the compiler figure out the
   appropriate input types.

 * Some of the file handling in Dispatch could overwrite other user files if
   they're named something we use for tmp files.

 * Testing:
   * Improve 'test' so that you can test a specific program's compiler output
     against its interpreter output.

   * There is something broken with the use of processes (System.Process).
     I'll get an error
       commitAndReleaseBuffer: resource vanished (Broken pipe)
     after some number of tests.  The failure comes from random specs in which
     external variable values have to be communicated to the C program.

   * Finally, the equivalence fails for specs containing external vars.  The
     reason is that right now, the generated C program needs to be executed to
     sample the external variables initially.  However, once it's executed for a
     period, all the streams are updated, so we're really into period 1.  So the
     interpreter and the compiler can diverge on the initial state, where in the
     compiler, variables that depend on sampled variables haven't captured their
     values yet .  They should converge after one execution.  Possible solutions
     include (1) ignoring the initial state, (2) or ensuring that variables are
     initially sampled---perhaps just calling the loop for one phase to do the
     sampling.

 * Do a test for a trailing '/' when giving a path in the setDir option.