O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

The Developer's Edge

Book Description

The Developer's Edge: Selected Blog Posts and Articles focuses on articles that are likely to be of interest to native language developers. The articles provide a broad overview on a topic, or an in-depth discussion. The texts should provide insights into new tools or new methods, or perhaps the opportunity to review a known domain in a new light.

Table of Contents

  1. Copyright
  2. About The Developer's Edge
    1. Why This Book?
    2. How This Book Is Organized
    3. Typographic Conventions
    4. Acknowledgements
  3. General Topics
    1. Why Scalar Optimization Is Important
    2. 32-Bit Good, 64-Bit Better?
    3. What About Binary Compatibility?
    4. Compiler Versions
    5. Single-Precision Floating-Point Constants
    6. Resolving Problems With Creating Reproducible Binaries Using Sun Studio Compilers
    7. volatile Keyword
    8. Finding the Canonical Path to an Executable
    9. STREAM and the Performance Impact of Compiler Optimization
    10. On Sun Studio and gcc Style
    11. Atomic Operations in the Solaris 10 OS
    12. Atomic Operations
    13. The Cost of Mutexes
    14. Using Large DTLB Page Sizes
    15. Page Size and Memory Layout
  4. Compilers
    1. Selecting the Best Compiler Options
    2. The Much-Maligned -fast
    3. Improving Code Layout Can Improve Application Performance
    4. Using Profile Feedback to Improve Performance
    5. Selecting Representative Training Workloads for Profile Feedback Through Coverage and Branch Analysis
    6. Using Inline Templates to Improve Application Performance
    7. Crossfile Inlining and Inline Templates
    8. Static and Inline Functions
    9. C99 Inline Function and the Sun C Compiler
    10. Catching Security Vulnerabilities in C Code
  5. Hardware-Specific Topics
    1. AMD64 Memory Models
    2. Kpic Under Small-Model Versus Medium-Model Code
    3. A Look Into AMD64 Aggregate Argument Passing
    4. On Misaligned Memory Accesses
    5. The Meaning of xmemalign
    6. Identifying Misaligned Loads in 32-Bit Code Using DTrace
    7. Calculating Processor Utilization From the UltraSPARC T1 and UltraSPARC T2 Performance Counters
    8. When to Use membars
    9. Flush Register Windows
    10. Sun Studio: Using VIS Instructions to Speed Up Key Routines
    11. Using the UltraSPARC Hardware Cryptographic Accelerators
    12. Atomic SPARC: Using the SPARC Atomic Instructions
    13. Reserving Temporary Memory By Using alloca
    14. alloca Internals
    15. alloca on SPARC
    16. Reading the Tick Counter
  6. Solaris Performance Primer
    1. Explore Your System
    2. System Utilization
    3. Process Introspection
    4. Process Monitoring With prstat
    5. Understanding I/O
    6. Understanding the Network
    7. Tracing Running Applications
  7. Developer Tools
    1. Cool Tools: Using SHADE to Trace Program Execution
    2. Performance Analysis Made Simple Using SPOT
    3. Adding DTrace Probes to User Code
    4. Adding DTrace Probes to User Code (Part 2)
    5. Adding DTrace Probes to User Code (Part 3)
    6. Recording Analyzer Experiments Over Long Latency Links (-S off)
    7. Detecting Data TLB Misses
    8. Locating DTLB Misses Using the Performance Analyzer
    9. Analyzer Probe Effect
    10. Analyzer Probe Effects (Part 2)
    11. Process(or) Forensics
    12. Runtime Checking With bcheck
    13. Locating Memory Access Errors With the Sun Memory Error Discovery Tool
  8. Libraries and Linking
    1. Calling Libraries
    2. LD_LIBRARY_PATH – Just Say No
    3. Dependencies – Define What You Need, and Nothing Else
    4. Dependencies – Perhaps They Can Be Lazily Loaded
    5. Lazy Loading – There's Even a Fallback
    6. Finding Symbols – Reducing dlsym() Overhead
    7. Using and Redistributing Sun Studio Libraries in an Application
    8. Dynamic Object Versioning
    9. Tracing a Link-Edit
    10. Shared Object Filters
    11. Reading or Modifying Hardware Capabilities Information
    12. Interface Creation – Using the Compilers
    13. Reducing Symbol Scope With Sun Studio C/C++
    14. My Relocations Don't Fit – Position Independence
    15. Building Shared Libraries for sparcv9
    16. Interposing on malloc
  9. Floating Point
    1. Measuring Floating-Point Use in Applications
    2. Obtaining Floating-Point Instruction Count
    3. Floating-Point Multiple Accumulate
    4. Using DTrace to Locate Floating-Point Traps
    5. Subnormal Numbers
    6. Enabling Floating-Point Non-Standard Mode Using LD_PRELOAD
  10. Parallel Code
    1. The Limits of Parallelism
    2. Introducing OpenMP: A Portable, Parallel Programming API for Shared Memory Multiprocessors
    3. Debugging OpenMP Code
    4. OpenMP 3.0 Specification Released
    5. Extending the OpenMP Profiling API for OpenMP 3.0