Path: utzoo!utgpu!news-server.csri.toronto.edu!cs.utexas.edu!sdd.hp.com!spool.mu.edu!uwm.edu!rpi!bu.edu!inmet!davidb
From: davidb@inmet.inmet.com
Newsgroups: comp.lang.vhdl
Subject: Re: VHDL Parallel I/O
Message-ID: <381900003@inmet>
Date: 29 Jan 91 16:05:00 GMT
References: <11686@pt.cs.cmu.edu>
Lines: 48
Nf-ID: #R:pt.cs.cmu.edu:11686:inmet:381900003:000:2350
Nf-From: inmet.inmet.com!davidb    Jan 29 11:05:00 1991


/* Written  1:04 pm  Jan 27, 1991 by jxw@fas.ri.cmu.edu */

>I believe that the LRM assures the modeler that any line will be read
>or written atomically, however if multiple processes read or write a
>single file at the same simulation time and delta, I do not believe
>that any order is implicit; further there is no implied monitor or
>critical section between a call endfile and a readline stmt.  Thus no
>modeler can expect deterministic execution of such a modeler and
>should avoid writing such a model.

See my answer to the other question; unless I am very much mistaken,
this question is null (file access cannot occur across multiple
processes).

>I would be nice if the LRM spelled out the meaning of each character
>type.  Given the ordering and symbology, ASCII clearly seems to be
>the IMPLIED meaning.  This implies that the last character in each
>line (denoted in a UNIX file system as '\n') should be mapped to LF,
>CR, or CR folllowed by LF as the last character of each line. For
>practical purposes, choosing the host's newline convention seems to
>make the most sense (for ASCII-based machines).  This character would
>seem to be just as readable as any other tag of type character.  This
>is what Auriga does.

This is deliberately left up to the implementation.

>QUESTION:

>It would be useful for a compiler to know about files which could be
>read during compilation, such as a ROM or PLA initialization.  Given
>the letter of the LRM, we need to wait until runtime to read in any
>file.  Such a statically read file would be useful, but cannot be
>reliably detected now (?) without using another readline procedure
>defined in another library (ugly).  Any ideas as to how this could be
>cleanly communicated to the compiler?

This question confuses me.  If the question concerns how a file can be
read prior to simulation time, a function call in an initializtion
expression can read an ASCII file and return an initialized array (in,
say, a constant).  This will occur at elaboration.  If you wish for
this to happen prior to elaboration, the only way I can think of is to
put it in a deferred constant, with the actual initialization given as
an aggregate in a package body.  If I am missing the boat completely,
please Email or post clarification, and I will try to respond.

						Dave Barton
						barton@i2wash.com