Tame® Release 4.41
Using Tame with
Microsoft Windows NT, Windows XP
And Windows 2000® Based Systems
Without Tame, use of DOS applications from Windows NT based systems may not be practical. This is due to excessive CPU usage of DOS apps, and also because the implementation of the DOS box is less than complete. Tame makes using DOS from Windows NT practical. Here is a partial list of the reasons why.
Tame can greatly improve overall system responsiveness when DOS applications are used.
Tame can help some applications become compatible with the multi-user environment.
Tame allows central management of DOS programs
To install Tame on a Windows system, run SETUP.EXE and answer the questions. For installation options, the defaults should be chosen in most cases. The notable exception is the installation path which defaults to C:\Tame. Change this to the system drive if the system drive is not C:.
Note: By default, the installation will update the autoexec.nt file so that Tame will be automatically loaded with each DOS application. If this option is not selected then you will need to change your icon or batch file to load Tame with selected applications. Also, if some applications are set up to use an alternate startup file then that startup file will need to be edited manually. To do this, run the following command line where alternate.nt is the name of the alternate file:
Notepad %SystemRoot%\system32\alternate.nt
Then add the following as the last line in the file
C:\tame\tame-mon.com
Some of these steps involve editing the registry. Most registry entries are in HKLM\Software\Tame. These steps may be done using regedit.exe or regedt32.exe. Sample .reg files are also provided to illustrate common changes. See the C:\Tame\Scripts folder.
Modern operating systems can increase productivity because more than one application can be run at the same time. However, most DOS applications are designed to run in a single-tasking environment. The typical DOS application acts as if it is the only program running on the computer. It spends most of its time waiting for its next 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 keystrokes, a program may poll the keyboard 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 in a multitasking operating system, this constant polling can waste a lot of CPU time. This is especially noticeable with multi-user systems, where several users are competing for CPU time. This unnecessary waste of CPU time severely degrades overall system performance.
Tame addresses this issue by releasing unnecessary CPU cycles while still allowing the DOS application to run full speed when it is really active. This can drastically increase the number of users that are supported on a multi-user system.
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 operating system to move on to the next task. When the operating system 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, allowing active tasks to run at full speed.
The running DOS application is watched by tame, and as the program runs, Tame places it into one of the following categories. These categories are listed sequentially beginning with a key press or program startup. Note that all the times and thresholds that are listed here represent defaults, and they may be adjusted as needed.
1. Boost – This represents the times where the application has work to do. It occurs when the application is first run, or right after a key press. Tame essentially gets out of the way and allows the application to perform the actions that were requested. While the application continues to update the screen, access the disk or otherwise show signs of doing work, Tame continues to extend the boost. While in boost, Tame will ignore most polling actions because many applications poll while working (e.g. to allow a key press to abort the work).
2. Job - After the application has been working continuously for a period of time, it may be considered to be a longer running job. Tame allows this job to consume CPU so that the work can complete as soon as possible. However, on single-CPU systems, this can degrade response time for other applications. Tame provides an option that will minimize the effect on other applications while still allowing it to complete as soon as possible. This is done by reducing the priority of the activity, allowing the operating system to be more responsive to user input in other processes.
3. Working - After the boost expires, Tame begins watching for signs that the application is still working or is idle. Until the application begins polling at a sufficiently high rate (50 times per tick), the application is assumed to be working, and Tame does not release its time slices. Note that most applications bypass this phase and go straight from Boost to Idle.
4. Idle – While the boost is not in effect, Tame watches for the application to show signs that it is idle. If an application begins polling at a sufficiently high rate (50 times per tick) then Tame will consider it to be idle. Because this is an inexact measurement, Tame does not take its most drastic idle action right away. Tame phases in increasingly aggressive responses to the application idle state, over a 2-4 second period.
Note that while Tame is switching away from the foreground task for increasingly long periods of time, keyboard response should not be significantly affected. Tame can detect when a key has been pressed and immediately re-enter the Boost phase.
Also, while the application is Idle, Tame returns to the application periodically to allow it the opportunity to do useful work, or more likely, to resume polling to verify that it is still idle. In order to determine if the application still idle, Tame enters a phase that is similar to the “Working” phase, except the idle threshold is lower (10 polls per tick).
4a. Idle Priority – This step is only available on Windows NT based systems, and is disabled by default. If enabled, Tame will simply lower the priority of the DOS thread to the “idle” priority level. This allows the task to burn CPU without slowing down other non-idle tasks.
4b. Single Switch - The first few times that Tame yields a time slice, it will switch tasks for 1/18 of a second, and then return to the application. If the application still does no useful work and continues to poll, then Tame repeats this process. This releases time slices very effectively while still allowing the application a limited opportunity to do further processing if necessary.
4c. Repeat Switch - After single switching for about half of a second Tame begins repeated task switching. In this phase, Tame will repeat the task switch, and only return to the application two times per second.
4d. Sleep - After 5 seconds of repeated switching, Tame begins more of a deep sleep. At this point, Tame sleeps for one second at a time. On a Windows based system, this reduces the number of context switches that are initiated by the task – from around 60 per second to one per second. If this context switch reduction is multiplied times many processes or users, it can dramatically decrease system load, and increase the number of users that may be supported on the system.
5. Boost – If a key is pressed, or if the application begins doing work that can be detected by Tame, the idle status is immediately terminated. This is the same as step (1) listed above, and the cycle repeats…
The following components of Tame may be installed.
|
File |
Purpose |
|
Tame.exe |
This is the console mode program that may be used to set options and display basic statistics. This program does not remain resident when running other applications. Tame.exe will load one of the other components when it is provided options that require a memory-resident Tame function. (e.g. Tame /run myapp) Tame.exe is not necessary in the Windows NT environment, though it may be used if desired. |
|
Tame-mon.com |
This program is loaded into memory and monitors application activity in order to optimize CPU usage. Of the two memory-resident components – Tame-mon is the one best suited for use by administrators and power users who may want to tweak Tame settings. |
|
Tame-res.com |
This program is loaded into memory and monitors application activity in order to optimize CPU usage. Of the two memory-resident components – Tame-res is the one best suited for use after the initial evaluation and setup period. It provides all the CPU reduction features of Tame-mon, but does not provide the ability to pop up over the DOS screen and view/adjust settings. |
|
TameVDD.dll |
This is a 32-bit component that is used when running Windows NT based operating systems. TameVDD.DLL works in conjunction with Tame-mon or Tame-res, and allows them to work more effectively with the Windows NT environment. With TameVDD.dll, Tame works more like a Windows application than it would if it had only 16 bit DOS components. For example, it allows using the registry to configure Tame. TameVDD.dll will be loaded by Tame-res or Tame-mon when they are run or it may be configured to automatically load when the NTVDM starts. |
|
TameView.exe |
TameView is a command line utility that simplifies administration and provides advanced diagnostics capability. TameView requires Windows NT version 4.0 or above, and is most effective on multi-user systems. |
The following options may be used with Tame.exe in order to control how Tame is loaded. They are not available with the Windows Virtual Device Driver, but may be used when running the TAME command. They may also be used when using the tame-mon or tame-res command because they use tame.exe to process the command line.
|
Option |
Description |
|
/CLeaR |
This option resets the totals that Tame displays on the status screen. This option will clear the totals that appear on both the pop-up status screen and the command line status screen. |
|
/Help |
This command provides a brief list of command line options. |
|
/Install |
This is the command you will use to load the Tame TSR into memory. Tame may 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. |
|
/RUN |
Run a command with Tame loaded. Specify the command line following /Run. The rest of the command line is passed to the program. Note that /Run must be the last Tame option. |
|
/Settings |
Load settings from a file. The default path is the path where Tame.exe is installed, and the default file extension is .TAM. |
|
/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 if Tame was previously loaded Tame using the /Install option. |
The following options may be used to tune Tame for best results with each application. These options may be specified on the Tame command line, in a settings file or as a settings Registry value.
Tuning options are listed in alphabetic order. Note that
many of these replace equivalent options from prior releases of Tame. Most of
the prior options are also supported if used on the command line, but not when
specifying settings via the Windows NT registry.
|
Option |
Description |
|
APp_Queue_Boost |
This may be specified in order to tune the /Watch_App_Queue_Work option. This parameter represents the application response time (in microseconds) that indicates it is sufficiently busy to warrant a boost. The default is 1000 microseconds, or one millisecond. |
|
APp_Queue_Work |
This may be specified in order to tune the /Watch_App_Queue_Work option. This parameter represents the application response time (in microseconds) that indicates it is busy, but not enough to obtain a boost. The default is 500 microseconds. |
|
APp_Queue_Idle |
|
|
Auto_SETtings_Detect |
This enables or disables automatic detection/adjustment of Tame parameters. |
|
Auto_SETtings_ticks |
This parameter specifies how many ticks Tame should allow the app to run before assessing the appropriate settings. |
|
Boost_CANcel |
This sets a poll rate threshold that will cancel the boost. By default, this is disabled so that the boost will not be cancelled due to a high poll rate. |
|
Boost_Dos |
Sets the number of ticks to boost after a DOS activity (e.g. Disk I/O) |
|
Boost_Irq |
Sets the number of ticks to boost after an IRQ (e.g. Serial port activity) |
|
Boost_Key |
Sets the number of ticks to boost after a key is pressed |
|
Boost_MINor |
Sets the number of ticks to boost after minor system activity |
|
Boost_Video |
Sets the number of ticks to boost after video activity |
|
CPU_Idle_Percent |
This option can help with some database or network bound apps that consume very little CPU while accessing the network. If the Tame finds that the app appears to be idle, but it happens that the app is consuming less than this amount of CPU then Tame will not force a time slice yield. |
|
CPU_Idle_TiMe |
This is the minimum length of Time that Tame will use to sample CPU usage after it appears that the app is idle. When Tame determines that the app may be idle, CPU usage is monitored until the app is seen to meet or exceed the CPU_Idle_Percent threshold, or until it begins doing other work. NOTE: This parameter is specified in milliseconds, and defaults to 55 (one tick). |
|
DOS_Idle_Poll |
Enable or disable interpreting the OS idle signal to mean that the application is idle. |
|
DOS_Idle_reSET |
Sets the poll threshold that should be used when the application issues the DOS idle signal. In some cases, it makes sense to reduce the threshold when the application reports that it is idle. |
|
Key_Idle |
This is the same as /Dos_Idle_Reset. |
|
Key_Poll |
This indicates that Tame should watch for keyboard polls. |
|
LOCK_REtry |
If a file lock request fails because another user holds the lock, this option causes Tame to automatically retry up to 8 times. This option can be useful if the application does not check the status and assumes that the lock was obtained. In most other cases, /LockYieldRetry is the preferred option. |
|
LOCK_Yield_All |
If a file lock request fails because another user holds the lock, this option causes Tame to yield the time slice before presenting the application with the bad news. This can prevent the application from burning CPU while waiting for the lock. However, if the application is just probing to see if the lock is available, it may cause an unnecessary delay. For that reason, /LockYieldRetry is generally the preferred option. |
|
LOCK_Yield_Retry |
If a file lock request fails because another user holds the lock, this option causes Tame watches to see if the application retries. If the application retries, and that lock attempt fails, Tame will yield the time slice before presenting the application with the bad news. This can prevent the application from burning CPU while waiting for the lock. |
|
Low_Priority_Ticks |
This enables the low priority option for Windows NT based systems. When set, it specifies the number of ticks that Tame should run the app at idle priority before yielding time slices. This may be set to 0 to skip the low priority phase. If set to –1 then the idle period is infinite (ended only by a key press or work/activity) – and Tame will never yield time slices. |
|
MONitor |
Enable the on-screen Tame monitor. This may be used for some basic diagnostic purposes. |
|
NONWORK_IDLE |
Enable idle detection whenever the application is not working. This can be necessary if the application does not poll while idle. |
|
PARallel |
Enable detection of parallel port (printer) activity, and provide a boost if detected. This is automatically enabled if the /SpoolPrintout option is specified. |
|
PSP_Poll |
This indicates that Tame should watch for PSP polls, which are occasionally more reliable than keyboard polls for determining if an application is idle. Note that this option is rarely needed. |
|
Poll_Idle_begin |
This sets the primary threshold in polls per tick for determining that an application is idle. |
|
Poll_Idle_2 |
This sets the secondary threshold in polls per tick for determining that an application is idle. This parameter is used after a task switch in order to quickly determine that the application is still idle. |
|
SERial |
Enable detection of parallel port activity, and provide a boost if detected. |
|
SLEEP_Time_slice |
This sets the amount of time In milliseconds that the deep sleep should yield to other tasks. |
|
SPOOL_Printout |
This causes Tame to expedite spooling to the printer in some cases where Windows normally delays 15 seconds or more to begin printing. When this option is used, the /Parallel option is also required. |
|
Switch_REPeat_Interval |
This sets how many ticks the task switch repeat should continue before giving the application a chance to indicate that it is (or is not) still idle. |
|
Switch_REPeat_Ticks |
This sets how many ticks the task switch repeat phase should continue before beginning the deep sleep phase. This may be set to 0 to skip the repeat switch phase. If set to –1 then this phase is infinite, in which case the deep sleep will not be initiated. |
|
Switch_REPeat_maX |
This sets the maximum number of task switches that are allowed before giving the application a chance to indicate that it is (or is not) still idle. This should normally be set to –1 or 255 so that the limiting factor is the number of ticks, not the number of twitches. This option is provided primarily to provide compatibility with earlier versions if Tame. |
|
Switch_Single_MINimum_Ticks |
This sets the minimum number of ticks that should be yielded while in the Single Switch phase. This is normally 1 so that one tick is yielded. When set to 1, if the task switch does not yield a full tick, it is repeated until a full tick has been yielded. This parameter may be set to 0 if a single task switch is really all that is desired. |
|
Switch_Single_Ticks |
This sets how many ticks the single switch phase should continue before beginning the next phase (normally repeat switch). This may be set to 0 to skip the single switch phase. If set to –1 then the repeat switch or deep sleep phases will not be initiated. |
|
Switch_Time_slice |
This sets the amount of time (in milliseconds) of the time slice that is yielded. This only affects Windows NT VDD based task switches. The default is 15 milliseconds. |
|
Time_Poll |
This indicates that Tame should watch for time polls, which are occasionally more reliable than keyboard polls for determining if an application is idle. Note that this option is rarely needed. |
|
Watch_APp_Queue_Idle |
Enable or disable watching for fast application response time in order to determine that an application is done working. |
|
Watch_APp_Queue_work |
Enable or disable watching for slow application response time in order to determine that an application is busy with a background task. |
|
Watch_BTRieve |
Watch for Btrieve and compatible SQL access, and boost while SQL is being processed. |
|
Watch_CONsole |
Enable or disable watching for console activity, and break from a yield prematurely when console activity is detected. |
|
Watch_SYStem |
Watch for Win32 I/O and page faults, and boost when they occur. |
|
Watch_eXtra_VIDeo |
When this is enabled, Tame will not ignore minor video activity such as cursor movement |
|
Work_Priority_Ticks |
This option can improve response time for interactive users by lowering the priority of a long running processes. This parameter sets the number of ticks an app working before it runs at a reduced priority. Note that the process may still show as close to 100% CPU usage, but you will find that user response is nearly as good as if the process is not running. |
|
Yield_VDD |
Enable or disable use of the TameVDD.dll for task switching. This is only a valid option when running in Windows NT and when specifying settings that are processed by the VDD. |
|
Yield_WINdows |
Enable or disable use of the native Windows task switching method. This is only a valid option when running in Windows NT and when specifying settings that are processed by the VDD. |
The following options are provided to improve the compatibility and functionality of some applications when run in the Windows environment. Some may help performance, but that is not the primary purpose.
|
Option |
Description |
|
DesqView_Aware |
Instructs Tame that the application is DesqView-Aware, and will release its own time slices using DesqView API calls. If this is enabled, Tame will translate the DesqView calls into those appropriate for the current operating system.. |
|
FORCE_TEXT_MODE |
Do not allow the application to enter graphics mode. Note that this is off by default, and some applications may become unstable if they attempt to enter graphics mode and cannot deal with this attempt failing. |
|
FOX_Video |
This option can speed screen repaints for some applications that were written using Foxpro. |
|
HOLD_DATE |
Do not allow date changes made in the DOS session to be passed on to the rest of the system, and do not update the date of this application to match the system date. This allows the application to change the current date for its internal processing purposes independently of the current date as seen by other applications. |
|
INITial_TEXT_MODE |
Do not allow the application to enter graphics mode during its initialization stage. This option can prevent some applications from forcing full screen mode if they sim0y pop in and out of graphics mode during initialization. This option is off by default, and some applications may become unstable if they attempt to enter graphics mode and cannot deal with this attempt failing. |
|
Key_Wait_Poll |
This indicates that Tame should poll the keyboard when the application requests a key and there is no key ready. This seems to be needed on many Windows based systems. |
|
LOCK_REtry |
If a file lock request fails because another user holds the lock, this option causes Tame to automatically retry up to 8 times. This option can be useful if the application does not check the status and assumes that the lock was obtained. In most other cases, /LockYieldRetry is the preferred option. |
|
LOCK_Yield_All |
If a file lock request fails because another user holds the lock, this option causes Tame to yield the time slice before presenting the application with the bad news. This can prevent the application from burning CPU while waiting for the lock. However, if the application is just probing to see if the lock is available, it may cause an unnecessary delay. For that reason, /LockYieldRetry is generally the preferred option. |
|
LOCK_Yield_Retry |
If a file lock request fails because another user holds the lock, this option causes Tame watches to see if the application retries. If the application retries, and that lock attempt fails, Tame will yield the time slice before presenting the application with the bad news. This can prevent the application from burning CPU while waiting for the lock. |
|
MONitor |
Enable the on-screen Tame monitor. This option is obsolete. The TameView utility provides a much more detailed view, and should be used instead. |
|
SMooth_TYPe |
This option can dramatically improve interactive response from the keyboard. With SmoothType, the keyboard response of most DOS apps can rival that of native Windows applications. This option is enabled by default. |
|
SPOOL_Printout |
This causes Tame to expedite spooling to the printer in some cases where Windows normally delays 15 seconds or more to begin printing. When this option is used, the /Parallel option is also required. |
|
TRACK_Queue_Time |
Enable QTime measurement even if no options are enabled that require it. |
Common options may be placed into a file if desired. The following files are installed with Tame. Other named settings are possible. To use custom settings, create a file containing the options that are desired.
|
Value Name |
Description |
|
BkGround |
This can be used for an application that runs in the background, and wakes on events other than keyboard input. |
|
Clipper |
This enables special options that need to be used for Tame to be effective with applications written in Clipper. Note that by default, Tame will attempt to detect when a Clipper application is run and automatically load these settings. |
|
ClipperQ |
Alternate Clipper settings that use the prevent slowdowns during printing and CPU intensive operations. |
|
MaxSpeed |
This Combination of options allows the app to run as fast as possible. In some cases, it may also use more CPU than is necessary. |
|
Inactive |
This file uses options that render Tame to be ineffective. This allows Tame to be loaded into memory without having any other effect. |
|
MinCPU |
This Combination of options allows the app to run using as little CPU as possible., In some cases, app may run slower than is necessary. |
|
NonPoll |
These settings may be used with an application that does not poll while idle |
The following registry values may be specified in HKCU\Software\Tame or HKLM\Software\Tame. They may also be in an application key which is a key off the Tame key with the name of the executable as the key name.
|
Value Name |
Description |
|
ConsoleTitle |
Set the title text of the console window. This can provide immediate confirmation whether Tame is (or is not) loaded in a process. The value may contain environment variable references that are expanded at run time. The following environment values are set by Tame for inclusion into the title: TameVersion, TameSettings, TameDosAppName, TameDosAppPath, TameDosAppArgs. |
|
InhibitMouse |
This option can be useful for applications that do not support use of a mouse. This option will reduce CPU usage by preventing mouse actions from interrupting the process. |
|
ProcessorMask |
This can be useful on a multi-processor system in order to limit which CPUs an application is allowed to run on. Specify 1 for CPU0, 2 for CPU1, 4 for CPU2, 8 for CPU3, etc… More than one CPU may be specified. To do this, provide the sum of the individual CPUs that are allowed to run the application. For example, a mask of 3 specifies CPU0 and CPU1. |
|
RunLogFile |
This is the path to a file where the run log is to be written. The path may contain environment variable references that are expanded at run time. |
|
ScreenLogFile |
This is the path to a file where the screen log is to be written. The screen log contains an image of all screens that the application displays, along with the task switches that Tame issues. This can be a very large file, so it should be enabled only when necessary for diagnostic purposes. This file will normally compress to a small fraction of its size. Compression is recommended if it is necessary to transmit or store this file |
|
Settings |
This specifies custom settings to be used with the application. Settings may be specified if needed by the application. This may be a string containing the command line options, or a string containing the name of the settings file. |
|
SingleThreadInit |
This specifies the name of the thread and enables single threaded startup. With this option, Tame will restrict the launches so that only one may initialize at a time. Once Tame detects that the first application is idle, the second is allowed to launch. This continues until all launch requests have completed. |
The following registry values may be specified in either the user registry key or the machine registry key (HKCU\Software\Tame or HKLM\Software\Tame). These values will be read only when the DOS box (NTVDM process) is created. Changes to these values are not applied to NTVDM processes that are already running.
Note that additional values may be specified in this area to serve as default settings for applications.
|
Value Name |
Description |
|
DosChangesDosTime |
Set this to true or false to specify whether time changes made by the DOS application are to be honored. When set to false, an error condition will be returned to the application if it attempts to update the system date or time. The default value is true. |
|
DosChangesSystemTime |
Set this to true or false to specify whether time changes made by the DOS application are to be applied to the system as a whole. The default value is false. |
|
SystemChangesDosTime |
Set this to true or false to specify whether system time changes are to be applied to the running DOS applications. The time change may not propagate right away. It will be passed to the DOS application on the next VDD task switch. The default value is false. |
|
SmoothTypeColor |
Note: If this option is desired, the recommended setting is a REG_DWORD value of hex 7FFF0008. This option provides visual feedback to assess the effectiveness of the SmoothType option. Portions of the screen show with different coloring for a brief period of time. This period is the difference in response time that SmoothType is providing. One effective way to use this is to keep the color the same and toggle brightness. With this in effect, portions of the screen show as bright letters, then suddenly become normal. If bright letters are showing, SmoothType is improving responsiveness. To use this option, create this as type REG_DWORD and set it to hex 7FFF0008. Other values require knowledge of screen attribute codes. Screen attributes are pits are selected using a bitwise and with the upper 16 bits and then exclusive or with the lower 16 bits. |
|
LogPath |
This specifies the name of a folder where log files should be placed. Note that if log files are used, this folder must be accessible with read and write privileges by all users. The path may contain environment variable references that are expanded at run time. |
|
TraceLogEnable |
This may be used to enable or disable the VDD trace log. The default is enabled if a TraceLogFile is set, so this value may be used to disable the use of the log without deleting the file name from the registry. Tame will also read this value from the user registry, where the user registry has precedence over the machine registry. This provides the ability to enable the trace for an individual user or group of users. |
|
TraceLogFile |
If this entry is set, trace of VDD operations may be dumped into the file. This is primarily a diagnostic log. This is a file that may be used to diagnose configuration issues. Note that it is not currently intended for tuning purposes. This registry value may be located in either the machine or user registry. The specified value may contain environment variable references (e.g. C:\Logs\%UserName%.TameTrace.Log). Not e that this is not the same file as the DOS trace log. The VDD trace log is much less verbose, and does not require post processing in order to view the log. |
The following values may be used in the Settings parameter
|
Value Name |
Description |
|
BkGround |
This enables special options that can speed up the video portion of some applications that run in the background. |
|
Clipper |
This enables special options that need to be used for Tame to be effective with applications written in Clipper. Note that by default, Tame will attempt to detect when a Clipper application is run and automatically load these settings. |
|
Settings File |
Additional settings files may be accessed if desired. The file may be specified by name only, as long as it is in the Tame directory. The default file extension is .TAM. |
|
/Options |
Any of the standard command line options may be specified. Note that this does not include many options that were provided with previous versions of Tame. For a complete list of options that may be included, see the Command Line Options. Section of this document. |
TameView is a separate utility that simplifies administration and diagnostics of DOS processes. The following functions are provided:
· Centrally manage all DOS processes without the need to visit client workstations
· View a compact list with basic information on each running DOS tasks
· Continuously monitor all DOS tasks
· Optionally filter the process list (e.g. list tasks that exceed a CPU threshold)
· List the current tame options and Tame statistics for any DOS task
· Provide a map of all modules that are loaded in a DOS process
· Display the contents of the current console screen of a DOS process
· List open files and file locks that are currently in use by a DOS process
· Initiate diagnostic trace procedures for a DOS user that may be experiencing problems
· Post-process diagnostic trace files
TameView can produce a summary of some or all of the DOS apps that are currently running. By default, TameView will list all DOS processes. A variety of Process Selection Options are available to filter which processes are included in the list. Here is an example of the summary screen.
|
Proc Elapsed Tot Cur Open Lock Last UserId Id Time CPU CPU Tame Status Files Stat QTime Command Full Command Line ------------ ----- -------- ---- ---- ------------ ----- ---- ----- -------- --------------------> LSKYWALKER 3392 10h 17m 0% 1% Z Sleep 6 n/a INVEN C:\INVEN\INV.EXE /F DEPT3.DAT HPOTTER 3508 2h 1m 1% 0% S Yield 2 32 INVEN C:\INVEN\INV.EXE /F DEPT3.DAT DVADER 4120 1m 15s 4% 0% S Yield 2 21 INVEN C:\INVEN\INV.EXE /F DEPT1.DAT JKIRK 5518 15m 21s 25% 72% Not Loaded n/a PINBALL C:\GAMES\PINBALL.EXE H9000 5590 2h 15m 2% 24% S Work D3E 4 1218 INVEN C:\INVEN\INV.EXE /F DEPT1.DAT
5 processes listed
|
The following information is provided for each process.
|
Value Name |
Description |
|
UserId |
This is the user name the process is running under. |
|
Proc Id |
This is the process ID that is assigned to the process. The process ID is assigned by the system, and it may be used to obtain additional information about the process. |
|
Elapsed Time |
This is the length of time that the NTVDM process (or DOS session) has been running. |
|
Tot CPU |
This is the percentage of a CPU that the process has used since it was started. On a multiprocessor machine, this is the percent of a single CPU, not the total CPU that is available on the machine. |
|
Cur CPU |
This is the percentage of a CPU that the process has used since the last TameView sample. Note that this is only available when the /I option is used to indicate that multiple samples are desired. |
|
Tame Status |
This represents the way that Tame is treating the process at this time. The following values may be displayed:
Status Meaning When the app is working, one of the following values will be listed in place of X in the status. W Meaning 1 IRQ activity B Btrieve activity D DOS activity (nn will list the DOS function) K A Key was read P Parallel port activity Q AppQ response time is slow, Application assumed to be busy S Serial port activity T A key was pressed by the user but not yet requested by the application V Video activity Y System activity (Win32 I/O or page faults recently detected) |
|
Open Files |
The number of files that the process currently has open. |
|
Lock Stat |
The lock status indicates the overall status of file locks that the application currently holds or needs. The status consists of a number which is a count of file locks that are held by the process. If the process is waiting on a lock that is currently held by another process, the letter “W” will also be included. This may be blank indicating that no locks are currently held or pending. Examples:2 two locks are held Note that more detailed lock status is available using the /LL command line option. |
|
Last QTime |
This is the most recent App Queue time. This is a measure of the response time of the application. For many applications, this is a low value while the app is waiting for input, and high when it is busy. For those applications, Tame can be tweaked for increased efficiency. To improve effectiveness in cases where the application does no I/O during busy periods, specify the /AppQueueWork option to be higher than the QTime that is seen while the app is idle and lower than the QTime value during busy times. To reduce CPU usage during idle periods, specify the /AppQueueIdle option to be slightly above the QTime that is common during idle periods and below that of busy times. |
|
Command |
This is the name of the program that is running. This will normally be the name of the EXE or COM file minus the extension. If the executable is listed as KRNL386.EXE then this is a process that hosts 16 bit Windows applications. |
|
Full Command Line |
This is the currently executing command line, including options. In some cases, this information is not available. |
Would you like to see what is going on with these processes? TameView can do that and much more. The following screen will analyze the process, display how Tame interprets it, and make recommendations for you to try if you believe that the interpretation of Tame is incorrect.
|
Process
ID : 3080 Elapsed
Time: 8.984 Seconds Tame
Options: /WorkPriorityTicks 20 /WatchAppQueueWork on /WatchAppQueueIdle on ─────────────────────────────────────────────────────────────────────────────────── ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
Tame may not be detecting when the application is idle. ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
|
If more detailed information is needed, additional Command Line Options are available to select which details are to be displayed. The ultimate level of detail is a full trace, which may be collected and post processed using the Trace Options.
TameView can display information or change one or more DOS processes with a single command line. Simple filtering is supported so that commands may be applied to all DOS processes that meet one or more criteria.
The following options may be used. If none of the /L options are specified then the compact table view with one process per line is displayed, and the default is to list all DOS processes. If any /L option is used then the default will list the DOS process most recently launched by the current user.
|
Option |
Description |
|
/I |
Repeat the view at a regular interval. The interval may be specified in seconds. The default value varies between 1 and 5 depending on the number of processes that are listed. |
|
/L |
List details about the process. This is equivalent to /LP /LM /LS /LF /LL |
|
/LC |
Show the console screen |
|
/LF |
List open files and enumerate sections of those files that are currently locked. |
|
/LL |
List file lock status including all file locks that are currently held. |
|
/LM |
List a memory map to include all modules currently loaded in memory |
|
/LO |
List Tame options that are currently in effect |
|
/LP |
Show a process summary |
|
/LS |
List Tame statistics |
|
/LVx |
Verbose options for list items that follow |
|
/M |
Continuously monitor selected details for the most recently launched DOS application for this user. |
The following options may be used to specify which processes apply.
|
Option |
Description |
|
/P |
Specify one or more process IDs |
|
/PA |
All DOS processes (may be further filtered by other options) |
|
/PC |
Select only processes that are using CPU. An optional parameter may specify the minimum CPU |
|
/PL |
List processes that are currently waiting on a file lock |
|
/PM |
List only processes where a specific module is loaded |
|
/PN |
List the most recently launched (New) processes. The number of processes to list may be specified, but normally the default ob 1 is used. |
|
/PT |
Select only processes where Tame is loaded |
|
/PU |
Select processes owned by the current user. The user ID may optionally be specified to select a different user. |
|
Option |
Description |
|
/TB |
Begin a DOS trace of the process. This option should only be used when directed by Tame support. The resulting file may be many megabytes, but it may be reduced to a small fraction of its size by using a compression utility. |
|
/TC |
Insert a comment into a running trace. Text of the comment should be quoted. |
|
/TE |
Stop the DOS trace if it was previously started. |
|
/TK |
Post process a DOS trace file to list the state before and after each key press and other significant events. Some of the information in the resulting file requires knowledge of DOS operation in order to interpret. The name of the trace file must be specified after this option. |
|
/TS |
Create a tick by tick summary of a DOS trace file. The name of the trace file must be specified after this option. |
|
Option |
Description |
|
/XA |
Add tame-mon.com to the autoexec.nt file |
|
/XR |
REMark tame commands from the autoexec.nt file (turns them into a comment line) |
|
/XS |
List the tame command(s) in the autoexec.nt file |
On a multi-user system, TameView may be used by an administrator to access any DOS session on the machine. A non-administrator may still run TameView, but access will be restricted to processes running in the same user session.
Tame is produced by David G. Thomas.
Email: dgthomas@tamedos.com
Web: www.tamedos.com
Address:
David G. Thomas
4290 Bells Ferry Road
Suite 106 PMB # 576
Kennesaw, GA 30144-1300