Free Download
Order  
License Keys
Downloads and Updates
  Advanced Development And Analysis Tools For Linux

Four Serious Tools In One Package                                          

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 positively illuminating.

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.

NightStar LX is available for most Linux distributions running on x86-based systems. Click here for a list of supported versions. Supported languages include C, C++ and Fortran compiled with either GNU or Intel compilers.

  • NightView Source-level Debugger

    Got a Heisenbug, where the act of debugging changes your app's behavior?
    Not with NightView. Experience incredible power and unparalleled control.


  • 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 used.



NightStar LX gives you true visibility into a running application -- providing a synchronized, time-based view of events, states, data values and resource usage.

Feature Overview

  • Deterministic debugging, monitoring, tracing and tuning
  • Ideal for time-critical applications
  • Easy-to-use graphical user interface
  • Support for any mix of GNU and Intel C/C++ and Fortran tasks
  • Self-hosted or remote target system operation
  • Comprehensive on-line help facilities
     
  • NightView™ Source-level Debugger
       - Multi-system, multi-process, multi-thread debugging via single interface
       - Hot patches including breakpoints, monitorpoint and watchpoints
       - Application speed conditions
       - Dynamic memory debugging
       - Modification and display of variables during execution

  • NightTrace™ Event Analyzer
       - Synchronized graphical or text display of system and application activity
       - User-defined event logging in single or multi-thread applications
       - Function calland parameter tracing
       - Data analysis API

  • NightProbe™ Data Monitor
       - Sampling and recording of program data
       - Synchronous and asynchronous data capture
       - Flexible data display features
       - Sampling, recording and replay

  • NightTune™ Performance Tuner
       - Dynamic display of system and application performance
       - Monitoring of CPU use, memory paging and network operation
       - Interactive control of processes, priorities, policies and interrupts
       - Dynamic CPU affinity control for processes, threads and interrupts
       - Detailed process and thread information

NightView Debugger

NightView 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

Language-sensitive Debugging

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.

NightTrace Event Analyzer

NightTrace 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 or event log 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 observation. The NightTrace graphical display is completely user-configurable for customized viewing. Configurations can be saved and later recalled, and multiple 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.

NightProbe Data Monitor

NightProbe 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 tool.

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.

NightTune System & Application Tuner

NightTune 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.

Application Tuning

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.

System Tuning

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.

If you have any questions, please email us at nightstar@ccur.com

NightStar Versions

NightStar tools are available on the following Linux distributions:

  • NightStar RT for Concurrent RedHawk Linux
  • NightStar LX for the following non-real-time Linux distributions:
    • Red Hat Enterprise Linux 4, 5 and 6
    • Fedora 9 through 16
    • CentOS 5
    • SUSE Enterprise Linux 10 and 11
    • openSUSE 10.2 through 12.1
    • Ubuntu 7.10 through 12.04
    • Debian 4, 5 and 6

    Not all NightStar features are supported by NightStar LX. Please consult the following table for details.

    Supported Tools NightStar
    RT
    NightStar
    LX
    NightView, NightTrace, NightProbe, NightTune  
    NightSim  
    Advanced Features
    NightTrace Kernel tracing  
    NightView Application speed eventpoint conditions and ignore counts  
    Non-intrusive signal delivery during debug  
    NightTune CPU and interrupt shielding  
    Detailed process memory information  
    NightProbe PCI device probing  
    Non-intrusive data monitoring/recording  
    Data monitoring and recording API