                                
                                
                                
                                
                                
                                TAME(r) release 3.34

                              Shareware Documentation

                       Copyright 1988-1996 by David G. Thomas








Tame is a registered trademark of David G. Thomas

-------------------------------------------------------------------------------
                                    Overview
-------------------------------------------------------------------------------

Introduction

   Tame will help you get maximum performance from your multitasking
   environment by speeding up the processing of your applications.

   TAME works with many MS-DOS based multitasking environments.  In fact,
   there are special hooks in TAME for use with most of the popular
   multitaskers including Windows, OS/2, Windows NT, Windows 95, DESQview, 
   Double Dos, Omniview, VM/386 and PC/MOS.


Installation

   The exact procedure to install Tame varies slightly depending on the
   multi-tasker that is being used.  See below for detailed instructions for
   installing Tame in your environment. 
   
   A generic installation that applies to all multi-taskers is as follows.

   Copy the distribution files onto the hard drive.  You may find it
   convenient to place the Tame directory in the path or to copy the Tame
   files into a directory that is in the path.  Another option is to copy just
   TAME.EXE into a pathed directory, and set the TAME environment variable to
   point to the directory where the rest of the Tame files are.

   Tame should be loaded into each DOS task.  To do this, type the following 
   command line.

      TAME /I

   Other options may be used to optimize performance if necessary.  I suggest
   you try the following.

      TAME /I 9

   If this makes the program run noticeably more slowly, try:

      TAME /I 5

   If this makes the program run noticeably more slowly, try:

      TAME /I 1

   A complete list of Tame options appears at the end of this document.


Why do you need TAME?

   Using a multitasking environment increases your productivity because you
   can run more than one application at a time.  While you are running a word
   processor in the "foreground", you can calculate a spreadsheet or print a
   report in the "background".  Although you appear to be getting several
   things done at the same time, multitasking can actually slow down your
   system.  This will continue to get worse as you run more applications at
   the same time.

   Most DOS applications are designed to run in a single-tasking environment.
   The application acts as if it is the only program running on the computer.
   It spends most of its time waiting for an instruction, and very little
   time carrying out the instruction.

   While the application is waiting, it queries the various devices
   (keyboard, mouse, etc.) to see if you have sent an instruction.  Then it
   checks again and again in a continuous cycle.  This constant checking is
   known as "polling". In just a few seconds between key strokes, a program
   may poll the keyboard hundreds or even thousands of times.

   All this polling uses a lot of the CPUs processing time.  In a
   single-tasking DOS environment with only one program competing for CPU
   time, polling doesn't affect performance.  There are no other applications
   competing for CPU time.

   But when you are multitasking, this constant polling wastes a lot of CPU
   time.  The background program is continually polling while you are trying
   to work in the foreground.  This unnecessary loss of CPU time from your
   foreground program makes it perform much slower.  That's where TAME can
   improve your performance.


How does TAME work?

   TAME re-allocates how the CPU spends its time.  It applies more CPU time
   to active tasks (like printing or spell-checking) and less time to idle
   tasks that are merely polling.  In essence, TAME speeds up your "active"
   work by slowing down your "inactive" work.

   TAME monitors what a program is doing.  TAME notices when a program is
   idle and its only activity is polling the keyboard.  After enough polls,
   TAME can see that the program is wasting time and tells the multitasker to
   move on to the next task.  When the multitasker returns to the idle task,
   TAME will be less patient than before and force a task switch as soon as
   the program starts polling again.

   When the program does something active -- such as processing keyboard
   input, performing disk I/O or changing the video screen -- TAME redirects
   the CPU's attention to it.  TAME detects the activity and boosts the
   program's priority for about a tenth of a second.  The priority boost
   prevents TAME from causing a task switch during that period of time.

   You may configure TAME to go so far as to instruct the multitasker not to
   waste any more time on a background task until it is brought into the
   foreground. Other TAME options may be used to help it correctly identify
   and deal with programs that are wasting your CPU time by polling input
   devices.

-------------------------------------------------------------------------------
                              License and Registration
-------------------------------------------------------------------------------

You are given a 30 day trial period to evaluate the effectiveness of Tame.  If
you decide to keep it, fill in the registration form (REGISTER.FRM), and send
it with $20 to the following address.

   David G. Thomas
   4290 Bells Ferry Road
   Suite 106 Room 576
   Kennesaw, GA 30144-1300

For more information, write to tame@tamedos.com or visit the web page at
http://www.tamedos.com

After receiving the registration fee, I will email a version of the program 
that has no delay screens or timeout period.  

NOTE: Checks must be made out to David G. Thomas, and payable in U.S. funds.

-------------------------------------------------------------------------------
                              Installation
-------------------------------------------------------------------------------

Installing TAME

   Tame is installed onto the hard drive by uncompressing the Tame archive
   file (TAME334a.ZIP).

   Once TAME is installed, there are several ways to run it.  With both
   DESQview and Windows 3.x, you may automatically add TAME to each program's
   window description, or you may manually edit each description to run TAME.
   With other multitaskers, you may load TAME at the DOS command line or from
   within a batch file.

   The quick start section is a starting point that quickly produces
   excellent results.  You'll effortlessly achieve almost all of TAME's
   potential benefits. When you feel comfortable with TAME, try the advanced
   features to achieve optimal performance of your system.


Quick Start

   Follow the quick start instruction to run TAME with the multitasker you
   are using.  If you use DESQview or Windows 3.x, you should then review the
   advanced setup options that follow the quick start.  When your setup is
   complete, refer to the section on how to test TAME with your applications.


DESQview Quick Start

   To automatically add TAME to DESQview, change to the C:\DV directory.  Now
   run the TAMEDVP update program to add TAME to the selected DVP window
   description.  For example, the following command lines add TAME to the
   default Big DOS (BD) window.

      CD \DV
      TAMEDVP BD

   TAME will be in effect the next time the window is opened.  Any existing
   BD windows will need to be closed and re-opened for TAME to affect them.
   Continue to run the TAMEDVP program for each DVP window description that
   needs TAME. Note that TAME will automatically add 10K to the memory size
   and modify the program options for the window you specify.  See the
   DESQview Advanced Setup for an explanation of the options that are
   automatically modified by TAMEDVP.

Windows 3.x Quick Start

   To automatically add TAME to Windows, change to the C:\Window directory.
   Now run the TAMEPIF update program.  This will add TAME to the selected
   PIF window description.  The following command lines add TAME to the
   Window's default window (_DEFAULT).

      CD \WINDOWS
      TAMEPIF _DEFAULT

   TAME will be in effect the next time the window is opened.  Any existing
   _DEFAULT windows will need to be closed and re-opened for TAME to affect
   them. Continue to run the TAMEPIF program for each PIF window description
   that needs TAME.  Note that TAME will automatically add 10K to the memory
   size and modify the program options for the PIF window you specify.  See
   the Windows Advanced Setup section for an explanation of the options that
   are automatically modified by TAMEPIF.


Other Multitaskers Quick Start

   First, make sure you are running in your multitasker.  Then, load TAME at
   the DOS prompt from within a window (or task).  Note that you may also load
   TAME from within a batch file, which is explained in the Placing TAME in a
   batch file section.

   To install the TAME resident (TSR) program that includes the pop-up
   screens, at the DOS prompt from within your multitasker, enter  TAME /I.
   You may also load the smaller version of TAME by entering  TAME /TINY /I.

   Now that TAME is active, load the application you want to run under TAME.
   For example, the following commands will load the TAME program that
   includes pop-up screens, and then load Lotus 123.

      TAME /I
      123

   Repeat these steps for each task you want to run with TAME.  Then test them
   as described in a later section.


DESQview Advanced Setup

   DESQview must be running before your begin.  Press the DESQview system key
   (Default is Alt) to be sure you are at the DESQview menu.  Press
   "OCP" for Open, Change a Program.  From the list, select the program that
   you want to tame.

   Examine the Program field to see which program the window runs.  If it is a
   command to run a batch file, then you may load the TAME TSR from within the
   batch file.  (See the section on Placing TAME in a batch file.)  Otherwise,
   you will need to change the DVP information as follows.

   Move the name of the program from the Program field to the Parameters
   field. Be sure to enter the program name before any parameters that were
   already in this field.  Enter the TAME /RUN command prior to the program
   name.  Now enter TAME in the Program field.  (Note that the TAMEDVP
   program will automatically do this for you.  If the DESQview "exit to DOS"
   option is set to NO, TAMEDVP will also add the /I option.)

   In the Parameters field, you may add any TAME options you want to run with
   this program.  You must place the TAME options prior to the program name.
   The /RUN command must always be the last TAME command on the line, and
   must be entered just before the program name.  For example, the following
   may be placed in the Parameter field to load the small TAME TSR, and then
   run Lotus 123.

      /TINY /RUN 123

   You need to increase the memory given to the task by 10K if you want to
   use the TAME pop-up screens, or by 2K if you do not need this feature.  If
   you don't specify the /TINY option when you run TAME, the 10K TAME TSR
   will automatically be loaded.  (Note that the TAMEDVP program will
   automatically increase the memory for you.)

   You may also want to set the two advanced options for "Run in the
   background" and "Share CPU in foreground" to "Y".  These two settings are
   frequently not used, but should work quite well with TAME.  Press the
   space bar at the Change a Program screen to move to the Advanced Options
   screen.

   Repeat these steps for each application you want to run with TAME.  Then
   test them as described in a later section.


Windows Advanced Setup

   Windows must be running before you begin.  Open the PIF editor window and
   edit the PIF file of the window that needs TAME.

   Examine the Program Filename field to see which program the window runs.
   If it is a command to run a batch file, then you may load the TAME TSR
   from within the batch file.  (See the section on Placing TAME in a batch
   file.) Otherwise, you will need to change the PIF information as follows.

   Move the name of the program from the Program Filename field to the
   Optional Parameters field.  Be sure to enter the program name before any
   parameters that were already in this field.  Enter the TAME /RUN command
   prior to the program name.  Now enter TAME in the Program field.  (Note
   that the TAMEPIF program will automatically do this for you.  If the PIF
   editor option to Close Window on Exit is set to NO, TAMEPIF will also add
   the /I option.)

   In the Optional Parameters field, you may add any TAME options you want to
   run with this program.  You must place the TAME options prior to the
   program name. The /RUN command must always be the last TAME command on the
   line, and must be entered just before the program name.  For example, the
   following may be placed in the Optional Parameter field to load the small
   TAME TSR, and then run Lotus 123.

      /TINY /RUN 123

   You may also need to increase the memory given to the task by 10K if you
   want to use the TAME pop-up screens, or by 2K if you do not need this
   features.  If you don't specify the /TINY option when you run TAME, the
   10K TAME TSR will automatically be loaded.  (Note that the TAMEPIF program
   will automatically increase the memory for you.)

   Repeat these steps for each application you want to run with TAME.  Then
   test them as described in a later section.


Placing TAME in a batch file

   Decide which TAME resident (TSR) program you want to use (the default TSR
   includes the pop-up screens, the other does not).  To load the default
   TSR, use the TAME /I command.  To load the smaller version of TAME, use the
   TAME /TINY /I command.  For example, place the following commands in your
   batch file to load TAME and then run Lotus 123.

      TAME /I
      123

-------------------------------------------------------------------------------
                       Testing TAME with your applications
-------------------------------------------------------------------------------

TAME can benefit nearly any program that uses CPU cycles to look for keyboard
input.  The best way to see if a program does this is to run a simple test.
You should test all programs that you use regularly, including word
processors, spreadsheets, editors, DOS shells, and communication programs.

The following explains several ways to test a program to see if it needs
TAME. Select the method you want to use.  If TAME appears to be needed, but
appears to have no effect, see Trouble Shooting in Appendix B.

1. Use a stopwatch

   This is the best way to measure TAME performance.  Note that other ways to
   test the effectiveness of TAME may be more convenient, but they are
   measuring performance indirectly and may occasionally yield misleading
   results.

   First, open a single window (W1) running DOS and make sure no other window
   is open.  If available in your multitasker, set the "Share the CPU" and
   "run in the background" options to Yes.

   Now, measure the time required to do a CPU or disk intensive operation.
   Choose any lengthy operation, such as copying a group of files.  Run the
   operation once without timing it so that the effect of other system
   enhancements (such as a disk cache) may be eliminated.  Run the operation
   again and record the time required.  This is the optimal time, since no
   multitasking is taking place.

   Now open another window (W2) and run an application that is not tamed.  Be
   sure this window (W2) is also set to "Share the CPU" and to "Run in the
   background".  Switch to the original DOS window (W1) and time how long it
   takes to run the same operation in the foreground.  Then time how long it
   takes the operation (W1) to run in the background with the application
   (W2) in the foreground.  If the original operation (W1) takes longer than
   the optimal time, then the application (W2) is slowing it down.  The
   application (W2) needs TAME.

   Note that you should expect a slightly slower time with the application
   running.  But, anything that takes more than 5% longer is not acceptable
   and needs TAME.

   Exit the application (W2) and run TAME in that window (W2).  Then run the
   application again in the window (W2) with TAME active.  Switch to the
   original DOS window (W1) and time how long it takes to do the same
   operation in the foreground, and then again in the background.  The timing
   should now be much closer to the original optimal time.  TAME has
   prevented the idle application (W2) from degrading system performance.

2. Use a standard CPU benchmark

   This is a variation of the stopwatch method where you use a CPU benchmark
   to time execution of a CPU intensive operation.  Use the same procedure,
   where lower stopwatch timing is equivalent to higher CPU speed ratings.

   NOTE: If you use Norton's System Information (SI) program for the
         benchmark, be sure it is version 4.5 or earlier.  The new versions
         of this program are capable of computing nearly the same number
         without regard to whether the system is loaded.  It may also
         erroneously report tamed systems to be slower than systems not
         running TAME.

3. Use the Geiger counter

   Another direct method is to run TAME with the /Geiger option.  This method
   will give you an audible indication for the effectiveness of TAME.  To do
   this, make sure no windows are open.  Then open a DOS window and at the
   DOS prompt enter:

      TAME /GEIGER

   You will immediately hear steady ticking; the Geiger's audible reference
   that the CPU is processing.  Now, open a second window and run the
   application you are testing.  Be sure TAME is not present.  If the ticks
   slow considerably, or if they become sporadic, the application in the
   foreground probably needs TAME.

   Now run TAME with the foreground application.  The ticks probably are
   smoother and faster than before.  This means TAME is keeping your
   background task running at nearly full speed, at least while you are not
   actively needing the CPU.

4. Check the visual indicators

   The monitor displays visual indicators to check system performance.  To 
   pop-up the monitor, press the hot-key sequence Alt-Ctrl-M.  This hot-key
   will toggle the monitor on and off.  If you are not using pop-up screens,
   load the monitor from the DOS prompt with the TAME /MOnitor command.  The
   monitor appears as a small a box in the upper right corner of the screen.

   Four symbols appear in the box from left to right that indicate System
   status, Current task status, Polling status and Task switch status.  The
   status that may appear in each of the four monitor positions indicate:

   S  = System status: (?) don't know, (I)dle, (W)orking

   C  = Current task: (I)dle, (W)orking, (i)dle switched, (K)ey read

   /  = Spinner: continuously turns while the system is polling

   .  = Task switch indicator: throbs as TAME causes task switches

   System status:  A ? means that the system is awaiting keyboard input, but
                   is not in a polling state.  An I indicates that a program
                   is running, but is currently in an idle state.  A W means
                   that a program is running and is actively processing.

   Current task:   
                   Both I and i indicate that the current task is idle, and a
                   W means that there is active processing in the task.  A K
                   means that the task is wait for a key stroke, but the task
                   is not in the polling mode.

   Spinner:        While an application is polling, the spinner will
                   constantly turn. When the application is active, the
                   spinner will stop.  For example, the spinner stops when you
                   are at the DOS prompt, or when an application is actively
                   printing, sorting, calculating, etc.

   Task switch indicator:  A constant throb means an application is inactive.
                   The throb will stop when the application is active.

   Use the spinner and task switch indicator to monitor an application.  When
   a task is idle, the spinner should turn and the task switch indicator
   should throb.  When active processing occurs, both should stop.  If an
   application is inactive and the spinner is turning but the task switch
   indicator does not throb, you need to lower the idle threshold for that
   application.

5. Check the TAME polling statistics

   Evaluate whether or not TAME is effective by running the application with
   TAME and then checking the statistics generated with the TAME /Status
   command.

   To test the program, TAME must be run in a multitasking window.  At the
   DOS prompt, type the following command line.

      TAME /I

   Now, run your program in this window and work in it for a short time. Then
   exit normally.  Type the following command line to obtain a summary of
   TAME activity.

      TAME /Status

   The displayed totals include the number of keyboard polls that the program
   performed.  If this number is small or zero, then TAME may not be needed
   with the application.  On the other extreme, some keyboard-hungry programs
   can generate thousands of keyboard polls in just a few seconds.  In this
   case, the application needs TAME.

Applications that are DESQview-aware

   Most sophisticated programs poll the keyboard.  A few of these programs
   have made themselves DESQview-aware, meaning that they recognize and work
   with DESQview.  Most are sufficiently DESQview aware to run in a window,
   but still hog the CPU.  These programs need TAME as much as ones that are
   not DESQview-aware.

   To be fully DESQview-aware, an application must release its time slice
   while it is polling the keyboard.  TAME is normally not needed when one of
   these fully-aware programs are used in DESQview.

   However, only a few programs are fully DESQview-aware.  With the ones that
   are, TAME can transform their DESQview-awareness into Windows-awareness,
   or awareness of any other supported multitasker.  This is done by
   specifying the /DVAWARE option.  When all programs that are run in a
   specific window will be DESQview-aware, you may turn off the options that
   cause automatic recognition of polling programs (except for communication
   programs.  The following command line tells TAME that all the programs
   will be DESQview-aware.

      TAME /DVAWARE /NKI /II NONE

   It is possible that a program uses DESQview/Topview functions that are not
   supported with TAME.  TAME can fool these programs into thinking they are
   in DESQview, but if they try unsupported functions, they may crash the
   system.  If

-------------------------------------------------------------------------------
                        Functional Option Summary
-------------------------------------------------------------------------------

   Usage: TAME /option [value] /option {value} ... [] = required, {} = optional

Common Options:

  /CLeaR
  /Help              {option}
  /Install           [1,5,9]
  /NoMonitor
  /OFf
  /ON
  /RUN               [command_line]
  /SETtings          [1,5,9]
  /Status
  /Uninstall

Tuning Options:

  /BackGround
  /NoBackGround      [count]

  /Boost             [key_boost work_boost]
  /Geiger            {delay time freq spinner}
  /Idle_Indicate     [first rest]
  /Idle_Indicate     [first rest] {POLLS}
  /Idle_Indicate     [Key,Time,PSP,NoWork,NONE]
  /NoIdle_Indicate   [Key,Time,PSP,NoWork]

  /KeyIdle           [count]
  /NoKeyIdle

  /KeyWaitPoll
  /NoKeyWaitPoll

  /TaskSwitchREPeat  [count]

  /Timer
  /NoTimer

  /Work_Indicate     [Com1,Com2,Com3,Com4,IRQn,SERial,PARallel,NONE]
  /Work_Indicate     [work_boost]
  /NoWork_Indicate   [Com1,Com2,Com3,Com4,IRQn,SERial,PARallel]

  /NoWorkTime        [first] {repeat}
  /NoWorkRange       [bytes]

Other Options:

  @filename
  /CLONE             [file command_line]
  /DVAware
  /NoDVAware

  /Hot_Key           [Monitor,Status key_name]
  /OFf               [ticks]
  /Task_Switch       [OS2,WINdows,DesqView,DoubleDos,OmniView,TopView,
                     VM/386,Key_Read,HaLT] {time_slice}
  /TINY
  /WriteOptions
-------------------------------------------------------------------------------
                       Detailed Option Summary
-------------------------------------------------------------------------------
 
@filename

   Tame will load preset command options from the file specified.  These
   options may have been previously placed into the file using the
   /Write_Options option.

/BackGround

   Turns off the /NoBackGround option.

/Boost [key_boost work_boost]

   This option is intended to prevent Tame from slowing an application.  It
   will boost the priority of the application for key_boost clock ticks after
   each key press, and work_boost clock ticks after each DOS or video action.
   Both values default to 2.  You may need to decrease the second value to zero
   if Tame does not seem to be effective.  See The Boost Parameter in the
   Advanced Options section for a detailed explanation.

/CLeaR

   Sets the totals that Tame displays on status screen to zero.  This option
   will clear the totals that appear on both the pop-up status screen and the
   command line status screen.

/CLONE [file command_line]

   This command will make a special version of the Tame TSR (the TAME-RES.COM
   that does not include the pop-up screens) that has customized default
   parameters, and will automatically run a specific command.  The currently
   active defaults will be placed into the cloned program.  In all cases, the
   /CLONE option should be the only command line option that is specified.

   The cloned program is specified with the file value, and should be named
   TAME-xxx where xxx is an abbreviation for the application name
   (TAME-123.COM).  You may optionally specify a command_line to automatically
   run a specific command.  Note that file is the name of the new COM file
   (without the .COM suffix), and command_line contains the full path name of
   the EXE or COM style command that is to be run.

   The new TAME-xxx.COM may then be run in place of TAME /I that is used when
   starting a new task.  See the section on Setting default options for a
   detailed explanation.

/CPU

   This command will calculate a suggested frequency threshold based on the
   speed of your CPU.  Tame sets this threshold to 3.  Unless your application
   runs slower under, you should not change the default frequency threshold.

/DVAware

   This command allows you to run DESQview-aware programs with multi-taskers
   other than DESQview.  See the section on Applications that are
   DESQview-aware for a detailed explanation.

/Geiger {delay time freq spinner}

   This option provides audible ticks that sound like a Geiger counter.  The
   ticks speed up when the system is idle, and slow down as other tasks demand
   CPU time.  This is a very useful tool for monitoring the effectiveness of
   Tame.  It allows you to monitor the amount of CPU that an application will
   use both when Tame is loaded and when it is not.

   There are some optional parameters that you may specify.  These options will
   vary depending on the speed of the CPU you are using.  When you run the
   Geiger command, it will display the current default values for each
   parameter.

   delay     The delay parameter sets the amount of time between each Geiger
             tick.  The default value is based on the speed of the CPU.  When
             you use Geiger for tuning your applications, you will want to use
             the default value for this parameter.

             However, you can set the Geiger to use very little CPU when Tame
             is loaded and tuned so you can monitor total system CPU usage.
             But, remember that doing this is not very useful for tuning Tame.

             To monitor CPU usage, specify a negative value for delay to set
             the real time between each tick in 1/18 second increments.
             Setting it to -1 will make a tick each 1/18 of a second.  Its only
             value in tuning Tame is in the fact that it will simulate a heavy
             keyboard poller, and may help you adjust the settings.  Setting
             delay to zero will give a tick each time this task gets a time
             slice, but the zero setting requires the Tame TSR to be loaded.

   time      This parameter sets the amount of time each tick takes.  The
             default is based on the speed of your CPU, and normally you would
             not want to change it.  You may set time as low as zero and a
             faint tick will still be heard.

   frequency This sets the frequency of the ticks in Hertz.  The default for
             this value is 100 Hertz.

   spinner   This option will display a spinner on the screen that visually
             supplements the ticking sounds.  You simply specify how often to
             move the spinner relative to the tick sounds; 1 means move it on
             each tick, two means for every other tick, etc.

/Help {option}

   This command lets you list all of the on-line help for Tame, or only help
   for a specific command or option.  Entering /H or /? provides the complete
   help document, one screen at a time.  To get help on a specific command,
   enter the full command or its abbreviation. For example, /Help HotKey or /H
   HK.

/Hot_Key [function key_name]

   You may assign the hot key you want to use to display either the Tame pop-up
   status screen or the pop-up monitor.

   function  You must enter either Status or Monitor to let Tame know which
             pop-up screen you are assigning a hot key.  If you do not enter a
             key_name, you will be prompted to press the key to assign.

   key_name  This is the name of the key you want to assign.  The name of the
             key may normally be derived by its label on the key cap.  The
             following names are valid.

             F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, Ins, Del, PgUp, PgDn,
             GrayMinus, GrayPlus, Left, Right, Up, Down, Home, End, TAB, ESC,
             Backspace, Enter, GrayStar, Space, A, B, ...  Z, 0, 1, 2, ...  9

          Also, any key may be modified as follows:

              Alt-Key
              Ctrl-Key
              Shift-Key
              Alt-Ctrl-Key

   For example, the following command line assigns the [Key: Alt-T] key to the
   Tame pop-up status screen.

      TAME /HK STATUS ALT-T

/Idle_Indicate [first rest]

   This option may help you fine-tune Tame.

   first This value sets the number of consecutive keyboard polls per clock
         tick that are acceptable before Tame decides that the program is idly
         polling the keyboard.  This number defaults to 3.  If this number is
         too low, then Tame may switch tasks while the program is really
         working.  You should set this number as accurately as possible.  You
         may run a special TAME /CPU command and Tame will compute a
         reasonable value that you may want to use based on the speed of your
         CPU.

   rest  If the application is inactive, Tame will wait first polls before task
         switching.  If the application is still inactive the next time Tame
         checks, it will wait only rest polls before task switching.  Tame will
         continue to wait only rest polls until the application again becomes
         active.  This number defaults to 2.  You will normally want to set
         this number low.

         You may set either of these values to -1, which indicates that Tame
         should not cause a task switch based upon polling alone.  This is
         effective with programs that issue the keyboard idle interrupt while
         they are polling the keyboard, and will prevent Tame from switching
         tasks based upon intermittent keyboard polls.

/Idle_Indicate [first rest] {POLLS}

   This is an alternate form of the previous option to specify that the values
   are not to be based on the time.  Instead, Tame will cause a task switch
   after first polls, even if the polls span several clock ticks.

/Idle_Indicate [poll_types]

   This option lets you specify the type of activity that Tame should check
   when considering polling.  You may select any combination of the following
   poll type values.

       Key       Tame should look for key polls.

       Time      Tame should look for time polls.

       PSP       Tame should look for PSP polls.
                 This is frequently helpful with network-aware programs.

       NoWork    Tame should detect the absence of work and assume that the
                 application is idle.  This detection may be restricted based
                 on /NoWorkTime and /NoWorkRange parameters.

                 Note that this parameter is recommended only with
                 applications that do not poll.

       NONE      Tame should not look at any type of polls.  This may be used 
                 as the first parameter in order to cancel any idle indicators
                 that are in effect before specifying new parameters.

/Install  {settings}

   This is the command you will use to load the Tame TSR into memory.  It may
   be removed from memory using the /Uninstall option.

   One of the standard settings may optionally be specified.  See the
   /Settings command for details on available settings.

/KeyIdle [count]

   This option works well with many programs that inform DOS when they are
   polling the keyboard while in an idle state.  Tame detects this idle
   situation and temporarily lowers the Idle Indicate first rest option to
   count.  You may set count set to -1 which tells Tame to never switch tasks
   unless the application confirms that it is really idle.

   This option may be turned off by specifying /NoKeyIdle.

   NOTE: With DESQview release 2.26 and later, this option is not recommended
          for tasks that spend a lot of time at the DOS prompt.  This is
          because DESQview detects the fact that Tame is watching the idle
          interrupt, and when at the DOS prompt, DESQview goes out of its way
          to make sure the idle interrupt is called.  This wastes some
          processing time unnecessarily.  This option is still very effective
          inside some programs, and the problem only occurs at the DOS prompt.

/KeyWaitPoll 

   Tame should look for the program requesting a key, and  continue a task
   switch until a key is pressed. This is frequently helpful in Windows and
   defaults to being enabled in Windows.

/Monitor

   This option turns on the monitor that displays Tame actions.  The same
   monitor displays whether you load it with the hot key or with this
   command.  The status monitor appears in the upper right hand corner of your
   screen, similar to the following.

      ͻ
      SC/*
      ͼ

   The status that may appear in each of the four monitor positions indicate:

      S = System status: (?) don't know, (I)dle, (W)orking
      C = Current task:  (I)dle, (W)orking, (i)dle switched, (K)ey read (B)usy
      / = Spinner:  continuously turns while the program is polling
      * = Task switch indicator:  throbs when Tame is causing task switches.

   The monitor may be turned off using the /NoMonitor option.


/NoBackGround [count]

   This option can be very effective with DESQview, and will be ignored if
   another multi-tasking system is being used.  When this option is specified,
   Tame will patiently do a normal task switch count times when the
   application is run in the background.  If no activity is detected, then it
   will instruct DESQview to temporarily run this program only while it is in
   the foreground.  As soon as this program is brought to the foreground, Tame
   will instruct DESQview to again allow it to execute in the background.

   For example, you may have a large spreadsheet to calculate and a lot of
   data to enter into a data base.  You can run the spreadsheet with the Tame
   /NBG command and move it to the background.  While it is calculating, you
   can be entering data in the data base.  When Tame detects that the
   spreadsheet is complete, it will put that background window to sleep and
   free the CPU for the foreground.  When the spreadsheet is brought to the
   foreground, Tame will again activate it.

   Note that you should not use this option with programs that need to start
   by themselves, such as communications programs and mail programs.

   This option may be turned off by specifying /BackGround.

/NoDVAware

   This option sets DESQview-aware programs so that they will not run with any
   other multi-taskers.  The programs will run only with DESQview.

/No_Idle_Indicate [poll_types]

   One or more activities may no longer be considered to be polling.  You may
   instruct Tame to no longer watch for the program to poll one or both of the
   following poll type values.

   Key           Tame should not look for key polls.

   PSP           Tame should not look for PSP polls.

   Time          Tame should not look for time polls.

   NoWork        Tame should not detect the absence of work.

/NoKeyIdle

   Turns off the /KeyIdle option.

/NoMonitor

   Turns off the visual Monitor.

/NoTimer

   This option prevents the application from processing the timer interrupt
   that is normally issued by the PC about 18.2 times per second.  This option
   may disable some features of the program, and should be used with caution.
   It is very useful with programs that use a lot of CPU time to process the
   timer interrupt with little benefit.  For example, a program that constantly
   displays the current time on the screen, but you are running the program in
   the background.

   This option works by intercepting the programs request to be called by the
   timer interrupt.  The program assumes it will be called on a regular basis
   by the timer interrupt, but, since Tame did not pass this request on to
   DOS, the program will never be called by the interrupt.

   This option may be turned off by specifying /Timer.

/No_Work_Indicate [activities]

   Define activities that Tame should not watch for to help it determine when
   the program is active.  You may enter any of the following values.

      Com1       Program does not access COM1 using hardware.
      Com2       Program does not access COM2 using hardware.
      Com3       Program does not access COM3 using hardware.
      Com4       Program does not access COM4 using hardware.
      IRQn       IRQ number n should not be monitored by Tame.
      SERial     Program does not access serial ports using the BIOS.
      PARallel   Program does not access the printer.

/NoWorkRange [bytes]

   Tame can detect that a program is doing no work, and interpret that as a
   signal to switch tasks.  Tame may falsely assume no work is being
   done if the program is using CPU but no other resources.  As a
   failsafe, Tame also checks that the program stack pointer is also
   fairly constant.  A truely compute-intensive application will
   normally be using the stack heavily.  Tame can detect this use and
   assume that work is being done.

   The stack change that is interpreted as work may be specified with this
   parameter.  The default is 30 bytes.  If Tame fails to detect work, lower
   this parameter, and if Tame fails to properly detect idleness, raise it.

/NoWorkTime [start_ticks] [retry_ticks]

   Tame can detect that a program is doing no work, and interpret that as a
   signal to switch tasks.  This parameter sets how long the program should do
   no work before Tame considers it to be idle.  A second time may also be
   specified, if you wish to use a lower tolerance after idleness is already
   detected.  
   
   The default is 8,1.  This will detect idleness after 8 ticks with no work,
   and after idleness is detected, switch after 1 tick of no work.

/OFf

   The /OFf option will temporarily disable Tame, but leave it in memory for
   later use.

/OFf [ticks]

   The /OFf ticks option will temporarily disable Tame for the number of ticks
   you specify.  Tame is automatically activated at the end of that time. This
   is beneficial when you need to load a program and not have Tame active
   until after the program is loaded.  Note that pressing a key will cancel
   this option.

/ON

   Enable Tame task switching.  Tame is on by default.

/RUN [command_line]

   Runs the command line with Tame active.  Any Tame options that are specified
   must be placed before /RUN and will be in effect while running the command
   line.

/SEttings settings_file

   Set Tame options to one of the standard settings.  The following settings 
   may be used:

       1 = Minimum taming of the application, and maximum detection of work;
           Use this level if Tame seems to slow the application.

       5 = Average taming of the application and maximum detection of work;
           Use this setting if maximum taming makes the program sluggish.

       9 = Maximum taming and maximum detection of work;
           Some applications may run slower with this setting.

   NOTE:  The options specified for each setting are listed in a file named
          *.SET (where * is the setting name).  You are free to add your own 
          settings by adding more .SET files to the Tame directory.

/Status

   Display a summary report.  The summary includes the number of task switches
   that were initiated by Tame, the total number of keyboard calls that the
   application made, and also a summary of the current options.

/Task_Switch [method]

   The main purpose of Tame is to switch to another task when it detects that
   the application is wasting time polling the keyboard.  With DESQview,
   Windows, Omniview, Topview, VM/386 and Double Dos, the native pause
   function is used to switch tasks.  Since Tame does not have specific
   support for other multi-taskers, you need to set the task switching method
   used by your multi-tasker.  
   
   The following task switching methods are available.

      DesqView   Use the native DESQview task switching method.

      DoubleDos  Use the native Double DOS task switching method.

      HaLT       The Halt option specifies that Tame should execute a HLT
                 instruction when polling is detected.  This instruction has
                 been found to cause some multi-taskers to immediately switch
                 to another task.  This is the default task switching method
                 when Tame does not recognize the multi-tasker.

      Key_Read   The Key_Read option specifies that when the program polls the
                 keyboard, Tame should tell a white lie and say that a key has
                 been pressed.  Most applications will immediately read the key
                 that Tame claimed was already pressed.  Since it really was
                 not pressed, DOS will wait for a key to be pressed.  Most
                 multi-taskers use this wait for a key press as a Que to switch
                 tasks.

                 The Key_Read option could be the most effective task
                 switching method in Tame, but it will not work with some
                 applications. Specifically, it will not work with any
                 applications that poll devices other than the keyboard, or
                 with programs that occasionally flush the keyboard buffer. It
                 is also not effective in Windows/386.

      OmniView   Use the native Omniview task switching method.  This requires
                 that Omniview is set up to be Topview compatible.

      OS/2       Use the native OS/2 task switching method.  The task switch
                 time may be adjusted using the /Task_Switch_Time parameter
                 which defaults to 100 milliseconds (1/10 second).

      TopView    Use the native Topview task switching method.

      VM/386     Use the native VM/386 task switching method which happens to
                 be the same as Halt.

      WINdows    Use the native Windows task switching method.  This is
                 effective with Windows 3.x and Windows NT.  It also seems
                 to work with some other multi-taskers such as OS/2.


/Task_Switch_REPeat  [count]

   When Tame detects an idle system and switches tasks, it will normally
   switch tasks once and then return control to the application.  This option
   causes Tame to continue to switch tasks a specified number of times without
   giving the application a chance to resume its polling ways.  The task
   switch repeat count will be terminated automatically by Tame if it detects
   a key press or other IRQ-based work (e.g. COM port activity).

/Task_Switch_Time {timeslice}

   Some multitaskers allow releasing for a specific amount of time.  The
   amount of time specified here is dependent on the multitasker in  use.  

   This option is currently supported only with OS/2.

/Timer

   Turns off the /NoTimer option.

/TINY

   This option will cause the small version of the resident Tame program to be
   loaded.  It is a fully operational version, except the pop-up status screen
   and pop-up monitor are not available.  If you use this option, it must
   always be the first option on the command line.

/Uninstall

   Remove the resident (TSR) portion of Tame from memory.  This is only
   necessary when you load Tame using the /Install option.

/Work_Indicate [activities]

   You may define the activities that Tame should watch for to help it
   determine when the program is active.  You may enter any combination of the
   following values, except that a maximum ot two IRQs may be monitored at
   any given time (Each COM port counts as an IRQ).

      Com1       Program accesses COM1 using hardware.
      Com2       Program accesses COM2 using hardware.
      Com3       Program accesses COM3 using hardware.
      Com4       Program accesses COM4 using hardware.
      IRQn       IRQ number n is activated by some hardware and should be 
                 detected by Tame.  Specify IRQ number 0 through 7.
      SERial     Program accesses serial ports using the BIOS.
      PARallel   Program accesses the printer.
      NONE       Program does none of the above.

/Work_Indicate [work_boost]

   This option sets the number of clock ticks after a work activity that TAME
   should elevate the priority of the task.

/Write_Options

   This option will write out all the current Tame parameters.  For best
   results, redirect output to a file.  When fine-tuning, you may want to
   check your current settings against the statistics on the Tame ANL report.
   The following example creates a file named TAMEOPT.DAT that contains all
   the current Tame options.

      TAME /WO >TAMEOPT.DAT

   This option works in conjunction with the @filename option.
