What happened to the '-x' option of dcopy(1M) ???

[M. G. Hand]

In article <172 at desint.UUCP> Geoff Keunning writes:

>In article <203 at pyuxt.UUCP> neal at pyuxt.UUCP (Neal Nuckolls) writes:
>
>>What would be the PURPOSE of forcing executables to be
>>stored contiguously?  This *could* reduce drive seeking if
>>accesses against the particular filesystem tend to group
>>in time with type (i.e. executable, non-executable).
>
>But they *do* group in time with their type, at least on a swapping system.
>A swapping system wants 100% of the executable at the same time;  this is
>obviously time grouping.  (On virtual systems, this is not nearly so clear).
>
>>In the case of mixed programs and their data on the same
>>filesystem and assuming that data i/o exceeds initial
>>text load the benefit from the '-x' option would be from
>>having the *non-executables* (data files) contiguous.
>
>Data files tend to be requested in much smaller chunks, and at much less
>predictable time intervals.  Head motion caused by other processes (which
>does not have to happen when you are loading an executable) will interfere
>with any advantages gained from making them contiguous.
>
>In general, any time you can predict the size of a disk read ahead of time
>there is an advantage in making the blocks involved in that read contiguous.
>On swapping systems, you always read in the whole executable.  This is not
>true in general of data files on any system.

I'm sorry, Geoff, but you clearly misunderstand what neal was saying, and
what dcopy does.   First, Neal was talking about the grouping of execution
of programs, (as in setting up a pipeline) not about the grouping of
blocks within files.  That leads me to the second point: "dcopy copies
files ... compressing directories by removing vacant entries, and
spacing consecutive blocks in a file by the optimal rotational gap."
(The gap is an option to the program, or its picked up from the extant 
file system).  The -x option used to force the files to be consecutive
with no intervening files of other types - that is what was meant by contiguous.
Clearly, unless you invoke several programs together (ie very quick succession)
you gain no benefit from this arrangement.

On the last point, you would only get an advantage from situations like:
	
	egrep reg-exp *

	or

	cat * | filter ...

and when, as Geoff says, no other disk access requests interferred with
position.

		Marcus Hand    (pyuxt!marcus)