
This is the code for the Omega Test. The interface for sage consists
in the file sagedriver.c and the include file lang-interf.h.
This is a preliminary interface, It does not use yet all the capabilities
of the omega test. More should follow.

Foloowing the original README for the tiny/omega test distribution.

********************************************************************
README file for omega/tiny distribution
README,v 1.1 1993/09/17 22:13:45 fbodin Exp
********************************************************************



This is the readme file for version 3.0.0 of the distribution of the Omega 
test, which is available via anonymous ftp from ftp.cs.umd.edu (128.8.128.8) 
in the directory pub/omega.

This release consists of three components:

     *  The Omega test: A system for performing symbolic
        manipulations of conjunctions of linear constraints
        over integer variables. In particular, the operations
        supported include:
                * Checking if integer solutions exist

                * Eliminating an existential quantifier. For example,
                  we can transform 
                        { Exists b s.t. 0 <= a <= 5; b < a <= 5b}
                  to
                        { 2 <= a <= 5}

                * Checking to see if one set of constraints implies
                  another. For example, we can check to see if:
                
                   {0 <= x <= 3; -3 <= 2y <= 3} => {0 <= x+y, x-y <= 3} 

                The interface to the Omega test is described
                in the file doc/omega_interface.tex

     *  The Omega test dependence analyzer: A system built on top
        of the Omega test to analyze array data dependences. This
        system builds the appropriate problems and makes the appropriate
        queries of the Omega test to analyze array-based data dependences
        in programs. The analyzer computes data difference/direction
        vectors, recognizes reduction dependences, analyzes array kills
        (which enables array expansion and array privatization), 
        and determines when assertions can be used to eliminate dependences.

        We have attempted to define an interface that allows other users
        to make use of the Omega test dependence analyzer. This interface
        is described in include/lang-interf.generic and Lang-Interf3.0 
        (keep in touch if you plan to use this interface; we are continuing 
        to refine it).

     *  Extended tiny. We have extended Michael Wolfe's tiny tool. The
        major extensions are:
        
                * Improved user interface (scrolling, dependence browsing
                  windows)

                * Capabilities that improve the accuracy of data dependence
                  analysis (induction variable recognition, forward
                  substitution).

                * Features that demonstrate the additional information we
                  collect (scalar/array expansion and privatization,
                  interactive dependence zapping)

                * An semi-automatic procedure for converting FORTRAN programs
                  into tiny

                * A prototype implementation of a unified framework
                  for reordering transformations. The framework 
                  unifies loop interchange, skewing, distribution,
                  fusion, reversal, statement reordering, and some
                  cases of access normalization, loop alignment, loop
                  peeling and index set splitting.

The Omega test is implemented on top of the December 1990 version of
Michael Wolfe's tiny program, as well as in a stand-alone test driver. 
The Omega test computes exact data dependence information, including checks
for array kills. The Omega test data dependence analyzer is substantially
more accurate than dependence analyzers in many existing research
and commercial systems.  

Tiny is a research implementation of an interactive program
restructuring tool.  Tiny computes data dependence relations
and interactively performs many restructuring transformations, such
as loop interchanging, distribution, skewing, ... .  Michael Wolfe
has put his tiny tool into the public domain, which allowed
us to build on top of his software. We are very grateful for Michael's
contributions.

This implementation is a research prototype and has not been subjected
to rigorous testing. In other words:

                THERE ARE BUGS IN THIS SOFTWARE

We don't know of any at the moment (other that the ones listed
under KNOWN BUGS/LIMITATIONS below), but we are sure that other,
undiscovered bugs remain in the software. This software has been 
put into the public domain as a public service on an "as-is" 
basis, without warranty or liability.

Since this version incorporates a large number of major new features,
there will almost certain be bug fixes that will be shortly released as
version 3.0.1.

If you register with us as someone who has a copy of the Omega test, 
we will send you update notices.  Send email to omega@cs.umd.edu to 
be added to the list of registered users. 

We are committed to continued distribution and support of the Omega
test for other researchers, and a number of research groups are already
incorporating the Omega test into their compilers and programming
environments. We welcome any additional researchers. Please stay
in contact with us if you plan to make serious us of the Omega test so
that we can provide you with updates and get feedback from your use.


The implementation of the Omega test and extensions to tiny have
been done by a number of people at the University of Maryland:
        William Pugh
        Dave Wonnacott
        Udayan Borkar
        Wayne Kelly
        Jerry Sobieski
        Vadim Maslov

This software is public domain, and no legal restrictions of any
kind whatsoever are placed on uses of it). You may do whatever you want 
with it, and no guarantees of any kind are made about its performance or 
lack of errors. You can copy it, use it, incorporate it or even sell it.
We request that any research or products that make use of this software 
acknowledge that use and that you keep us informed of your use.

Please send mail to omega@cs.umd.edu if you wish to be added to a mailing
list for people interesting in using this software. We will notify
people on the mail list of bug fixes and new releases.

Also send mail to omega@cs.umd.edu if you have any trouble installing
the software, bug reports or questions. 

Our work on this software has been supported by NSF grants CCR-8908900 and 
CCR-9157384 and by a Packard Fellowship, as well as being based on
Michael Wolfe's original implementation of tiny.


                                FILES
                                -----
The following tar files can be ftp-ed from ftp.cs.umd.edu (128.8.128.8) 
from the directory pub/omega:


 * README           This file
 * WOLFE_README     The readme file that originally accompanied Michael Wolfe's
                    distributing of tiny
 * src.tar.Z        Source for the omega test and our enhanced version of tiny
 * sparc_demo.tar.Z Sun Sparc executable versions of the programs that can be
                    made from the src files, demo files, and documentation of
                    of how to use our extended version of tiny.
 * dec3100_demo.tar.Z Decstations 3100 executable versions of the programs that 
                    can be made from the src files.  demo files, and documentation of
                    of how to use our extended version of tiny.
 * demo.tar.Z       Test files for demos
 * rt.tar.Z         Regression test files
 * doc.tar.Z        Documentation
 * techReports      A directory containing postscript and dvi copies of
                    relevant tech reports.

Together, these tar files constitute the entire tiny system, with the
following directories:

 * include header files (from src.tar.Z)
 * src     source code (from src.tar.Z)
 * obj     makefile (from src.tar.Z), generated files (from sparc_bin.tar)
 * doc     documentation for tiny and for other drivers for the omega test
 * demo    sample files documented to show features of the Omega test and
           extended tiny
 * f2t     A FORTRAN to tiny converter based on f2c
 * rt      regression test sample files and expected results
 * misc    shell scripts used for regression testing (rt.tar and src.tar)

The executable programs are:

 * "t"       the tiny environment, upgraded to use the omega test and
             test for refinement, killing, and covering of dependences

 * "f2t"     A FORTRAN to tiny converter based on f2c


