Fast track meeting 07-19-2004
Attendance
 John Ries
 Steve Bailey
 Dave Bishop
 Charlie Guy
 Peter Aschendend
 Ajay 
 Ryan Hinton
 Chuck Swart
 Karl Eisnhofer

Steve Bailey Running meeting

FT15

  Why do we want to do this? General response is for image processing and
  working around the problem of unconstrained arrays of unconstrained arrays.  A
  major issue is the type of a multi-dimensional slice if some indicies are not
  slices.

  Current proposal produces an anonymous type for slices that decimates the
  array. An array is decimated if some dimensions are slices and some are single
  indexes.  Since this anonymous type is unique, the user would be required to
  always cast result. This causes a problem with decimated slices as lvalues,
  left hand side of assignment, , port maps, and subprogram parameters because
  type conversions cannot occur in these locations.  The VHPI maybe impacted
  because expressions must have a type, the anonymous types can be an issue
  here. Steve suggested that we allow for overloading of slices so that we can
  have the return type specified.  Overloading has a number of considerations.
  Another issue is can synthesis can infer correct hardware with
  multi-dimensional slices?.  Can multi-dimensional slices be used in aliases?
  If so, this would conflict with the current view that arrays are contiguous
  memories.  Discussion about deferring FT15 to the next revision.

  FT15 will be deferred to next revision.

FT9
  From DAC there was an issue on can there be parsing problems with physical
  types.  From John, there isn't a problem here. Dave brought up the issues of
  fixed point and floating point constants. The fixed point and floating point
  constants will not to be added to FT9.  Issues on item C of proposal. Do we
  handle signed and unsigned in the literal?  Resolution is to keep C as
  is. Action item for John to add negation example.


FT24 Don't Care in Case.

  Number of issues with this proposal.

  One issue is match vs not match function for the ?= function.

  When is the check for mutual exclusive choices done.  If the ?= function is
  user defined then check can not be done at compile time.

  How do we handle strength removal? One solution is to use the to_01X function
  on the selector expression to remove the strength. Another is to define define
  equivalence sets on the type.

  Do we need to have two case statements, one that doesn't have a  don't care
  and one that has don't care and equivalence sets?

  Proposal doesn't allow don't care for type bit. Why can't we use this with
  bit? Because the don't care value must be in the type itself and bit only has
  two values.  Do we need to allow defining of an extra meta states for all
  other types. Another possibility would be to define another bit type with a
  don't care value.

  A suggest was to use a wild card character instead of a don't care. So,
  "---11" would be written ..."11" or ---"11". This has a problem of which
  character to use for the wild card. There is also a problem with building up
  an expression of a constant because they must be single value and set of
  values. A wild card could also cause confusion with std_logic's '-'.

  Discussion on the trade off of having user defined function vs. explicit
  configuration of function.  If we have explicit configuration, then the tool
  can enforce the behavior and knows what it is.  But if it is a user defined
  function we have a number of issues like overloading, argument types, do the
  arguments have to be the same type, must the arguments have to have the same
  length if the are array types?

  Action item for John is address strength reduction stuff.  Action item for
  John to list the pro and cons of user define functions vs. predefined.

Close of meeting