Unlike ordinary debuggers, NightStar LX doesn’t
leave you stranded in the dark. It’s more than just a debugger,
it’s a whole suite of integrated diagnostic tools designed
for complex Linux applications to reduce test time, increase productivity
and lower costs. You can debug, monitor, analyze and tune with
minimal intrusion, so you see real execution behavior. And that’s
Time-critical applications require debugging tools
that can handle the complexities of multiple processors, multitask
interaction and multithreading. NightStar LX advanced features
enable system builders to solve difficult problems quickly. The
same tools proven by the automotive, aerospace and defense industries
are now available to you.
NightView Source-level Debugger
Got a Heisenbug, where the act of debugging changes your app's
Not with NightView. Experience incredible power and unparalleled
NightTrace Event Analyzer
Graphically display application behavior and performance,
and understand how your threads interact with each other.
NightProbe Data Monitor
Monitor, display and log application data. Playback application
data from pre-recorded runs.
NightTune System and Application Tuner
Get the big picture. Monitor priority, scheduling policy, CPU assignment
and usage, context switches, interrupts, memory paging, network
activity and more.
All tools include context-sensitive, on-line documentation.
Help is available by simply clicking on the tool feature being
NightStar LX is available on any x86-based system
running Red Hat Linux Enterprise 4 or 5, Fedora 7 or 8, SUSE Linux
Enterprise Server 10 or Desktop 10, openSUSE 10.2 or 10.3, Ubuntu
7.10, Debian 4.0 and CentOS 5. Supported languages include C, C++
and Fortran compiled with either GNU or Intel compilers.
• Deterministic multi-core debugging, monitoring, tracing
• Ideal for time-critical applications
• Easy-to-use graphical user interface
• Support for any mix of C/C++, Ada and Fortran tasks
• Self-hosted or remote target system operation
• Comprehensive on-line help facilities
• NightView™ Source-level
- Multi-system, multi-process and multi-thread debugging via single
- Hot patches including breakpoints, patchpoints, monitorpoints
- Application speed conditions and ignore counts
- Dynamic memory (heap) debugging
- Modification and display of variables during execution
• NightTrace™ Event
- Synchronized graphical or text display of all system activity
- User-defined event logging
- OS event logging including system calls, interrupts and exceptions
- Precision time-stamping of all events
- Powerful data analysis API
- Function call and parameter tracing
• NightProbe™ Data
- Unintrusive sampling and recording of program data
- Synchronous and asynchronous data capture
- Flexible data display features
- Program data modification
- Sampling, recording and replay APIs
• NightTune™ Performance
- Dynamic display of system and application performance
- Monitoring of CPU use, memory utilization and network operation
- Interactive control of CPUs, priorities, policies, shielding
- Dynamic CPU affinity control for processes, threads and interrupts
- Detailed process and thread information
allows users to simultaneously debug multiple, time-critical processes.
With NightView, a programmer can change program execution and modify
or display data without stopping or interrupting the program. Eventpoint
conditions, such as hit and ignore counts, are patched directly
into an application.. NightView provides fine-grained control without
adversely affecting application timing.
NightView monitorpoints can display expressions at user-selected
locations without stopping a process, thus providing data displays
that are synchronized with the application's algorithms. Watchpoints
utilize hardware address trap features that cause an application
to stop when user-specified variables or memory locations are
selectively read or modified
NightView supports the debugging of multiple applications
written in any combination of C/C++ and Fortran. All variables
and expressions in each program are referenced in the appropriate
language. NightView is also integrated with the NightTrace event
analyzer. NightView can insert tracepoints at user-specified
locations for concurrent or post execution analysis by NightTrace.
More Powerful Than The Gnu Debugger
NightView offers many features not available in the
gnu debugger (gdb). The advantages of NightView include the ability
for users to debug multiple processes from a single session and
processes started from scripts. While a process is executing,
hot patching can modify variables or add eventpoints. Monitorpoints
can display expressions and stack variables, and signals can
be sent directly to the process, bypassing the debugger.
Complete Memory Debugging
NightView includes an interactive memory debugger that
helps find and eliminate memory problems during the debug process
without code recompilation. NightView watches for heap memory
leaks, monitors the amount of memory an application uses, and
tracks how it allocates and frees memory. With its memory debugger
enabled, NightView lets users track heap allocations and deallocations
in real-time, thus allowing for more efficient debugging than
post-run analysis. Programmers can stop execution, check for
problems, test patches and then continue debugging.
is a tool for displaying and analyzing the dynamic behavior of
applications. NightTrace can log events from multiple processes
executing simultaneously on multiple CPUs. NightTrace creates a
graphical time-based view of all logged events. NightTrace allows
users to zoom, search, filter, summarize and analyze events. Tracing
analysis can be performed live or post execution.
NightTrace was specifically designed to meet the most stringent
requirements of time-critical applications. Using synchronized,
fast-access hardware clocks and kernel-free primitives, NightTrace
tracepoints are logged with minimal overhead. Tracepoints can
be inserted into device drivers, interrupt level code and any
user application. Tracepoints can be left in production-quality
applications even when not collecting trace data.
Graphical and Interactive
NightTrace graphically displays requested events and
states along a timeline graph to clearly show the relative timing
of events and provide an overall picture of application and operating
system activity. NightTrace can locate specific events and zoom
in on them with a fine degree of granularity for precise timing
The NightTrace graphical display is completely user-configurable
and customizable. Configurations can be saved and later recalled,
and different configurations can be viewed simultaneously.
Automatic Function Call Tracing
NightTrace’s application illumination feature
allows programmers to automatically trace application function
calls and examine the values of parameters passed and returned.
Function call tracing is fully customizable and can provide a
complete view of glibc activities.
NightTrace generates source code using an Analysis API that
allows users to easily create custom applications that monitor
or analyze application or system activity.
is a tool for independently monitoring, modifying and recording
data values from multiple application resources, including programs,
shared memory segments and memory mapped files. NightProbe can
be used in a development environment for debugging, analysis, prototyping
and fault injection, or in a production environment to create a
GUI control panel for program input and output.
Synchronized and Asynchronous Logging
NightProbe logging can be performed via on-demand sampling
or a cyclic clock rate. NightProbe provides for logging data
items using tracepoints for simultaneous analysis by the NightTrace
event analyzer. Sampled data can be combined with kernel trace
and additional user trace data to obtain a synchronized picture
of application and operating system behavior. NightProbe can
record data to disk files or provide data directly to the NightTrace
Interactive Sampling and Modification
NightProbe provides a flexible spreadsheet display for
on-demand or cyclic sampling of data at user-specified refresh
rates. Direct modification of user data is accomplished by typing
in new values for data items into the spreadsheet. NightProbe
provides colorized notification of violations of user-defined
data thresholds for individual data items.
NightProbe supports scalar and structured data types in C/C++
and Fortran that have statically-determined addresses and shapes.
NightProbe scans the symbol table and debug information of user
programs allowing the user to browse for data items or specifically
entering the names of data items to be monitored. Any application
that contains symbol table and debug information may be used
with NightProbe. No application source code changes are required.
System & Application Tuner:
provides a graphical interface to system facilities for monitoring
and tuning application and system performance. Users can monitor
the priority, scheduling policy, CPU assignment and CPU usage of
user applications. NightTune also monitors system CPU usage, context
switches, interrupts, memory paging and network activity.
NightTune can monitor processes individually or in userspecified
groups or by CPU. NightTune also displays information about individual
threads or tasks within a process. Available information includes
library and system call tracking (strace), file descriptor usage
and connections, signal states, and detailed memory usage with
page-level statistics on residency, locking and NUMA pools. Multiple
frames and windows are used to display information allowing users
to customize the desired display.
NightTune allows users to change the process attributes of an
individual thread, task, process or group of processes as a
whole using pop-up dialogs and drag-and-drop actions. For example,
dragging a process icon to a CPU icon binds the process to
that processor. The user then instantly sees the results of
the tuning effort both graphically and as text.
NightTune allows users to change the CPU assignment of interrupts
using pop-ups or drag-and-drop actions. NightTune optionally
provides a textual log of all application and system tuning
actions taking during a NightTune session.