Career-related questions are common during NVIDIA cybersecurity webinars and GTC sessions. How do you break into the profession? What experience do you need?…
Career-related questions are common during NVIDIA cybersecurity webinars and GTC sessions. How do you break into the profession? What experience do you need? And how do AI skills intersect with cybersecurity skills?
The truth is, that while the barrier to entry may seem high, there is no single path into a career that focuses on or incorporates cybersecurity and AI. With many disciplines in the field, there is a massive need to grow the cybersecurity workforce. According to the (ISC)² 2021 Cyber Workforce Report, the global cybersecurity workforce needs to grow 65% to effectively defend organizations’ critical assets.
Whether you’re just starting your career or are looking to make a mid-career change, read on for five tips to help you break into the field.
1. Evaluate your raw skills
Organizations of all sizes are facing a cybersecurity skills gap. Fortunately, the skills needed to work in cybersecurity are not strictly defined. Everyone has a different skill set and can bring something unique to the table. Evaluate your skills with the following questions:
Are you curious? Cybersecurity professionals investigate, ask questions, and figure out how to optimize processes and tools.
Are you good at explaining concepts? Communicating with both technical and non-technical audiences, including customers, is a highly valued skill.
Do you like building (or breaking) things? Cybersecurity practitioners are constantly optimizing and building.
Do you like analyzing data? Identifying patterns and behaviors is often required when you work in cybersecurity.
Are you calm under pressure? Responding to reports of security vulnerabilities and active security incidents helps protect customers.
Taking a close look at your raw skills and strengths helps narrow down the roles that might be right for you.
2. Determine which areas and roles interest you
Cybersecurity touches every aspect of business, which means you can contribute in a variety of specific areas and roles, including:
IT Operations – Are you technical? Are you a builder? Do you like to analyze data? Cybersecurity practitioners and teams are typically part of IT Operations.
Marketing and Communications – Communicating in a way that a variety of audiences can understand is essential in cybersecurity. While they may not be traditional practitioners, marketers and PR managers are critical in the cybersecurity industry.
Training – Building training programs around cyber hygiene and company policies may be right for you if you enjoy teaching.
Risk Management and Compliance – Evaluating cyber risk is on every leader’s mind. Risk managers who specialize in cyber risk and compliance are valuable.
Architect or Engineer – Designing and building secure products and services are imperative to protecting any organization’s assets.
Figure 1. Evaluate your skills in the context of cybersecurity career opportunities
3. Build connections with subject matter experts
Connecting with experts in the areas you don’t know well can be a tremendous help as you begin your career. This is particularly true if you are interested in a career that incorporates cybersecurity and AI.
If you have a background in data science or AI, and cybersecurity is now piquing your interest, reach out to cybersecurity professionals within your organization. Shadow them, learn from them, and exchange information. Become each other’s counterparts and figure out how combining your skills can have a positive impact on the security of your organization.
4. Identify cybersecurity issues that AI can solve
Cybersecurity and AI are becoming increasingly intertwined. Individuals who understand both are in demand in the current workforce. More specifically, the industry needs those who understand cybersecurity and AI deeply enough to identify when, where, and how to apply AI techniques to cybersecurity workflows.
If a career that combines cybersecurity and AI interests you, start defining use cases for applying AI to cybersecurity. What challenges do you think AI can solve? Simply identifying these use cases is beneficial to security teams and can help you hit the ground running.
5. Invest in your professional development
Learn from experts and invest in your professional development. Take time to research courses and events. NVIDIA offers a range of cybersecurity sessions twice a year at our GTC conferences. Many of these sessions are available year-round through NVIDIA On-Demand. You can also take courses year-round through the NVIDIA Deep Learning Institute. Once you’re hired, on-the-job training is common in the field of cybersecurity.
Check out other industry conferences like RSA, Blackhat, DefCon (AI Village), regional BSides, and InfoSec. The Camlis Conference is an annual event that gathers researchers and practitioners to discuss machine learning in cybersecurity. USENIX Security Conference brings together researchers, practitioners, system administrators, system programmers, and others interested in the latest advances in the security and privacy of computer systems and networks.
If you’re interested in a career in cybersecurity, evaluating your skills is a good place to start. Then research opportunities in the field and be proactive with your professional relationships and development.
When it comes to reimagining the next generation of automotive, NIO is thinking outside the car. This month, the China-based electric vehicle maker introduced its lineup to four new countries in Europe — Denmark, Germany, the Netherlands and Sweden — along with an innovative subscription-based ownership model. The countries join NIO’s customer base in China Read article >
When developing on NVIDIA platforms, the hardware should be transparent to you. GPUs can feel like magic, but in the interest of optimized and performant games,…
When developing on NVIDIA platforms, the hardware should be transparent to you. GPUs can feel like magic, but in the interest of optimized and performant games, it’s best to have an understanding of low-level processes behind the curtain. NVIDIA Nsight Developer Tools are built for this very reason.
Imagine a proud homeowner who lives in a house that they love and want to take care of. Of course, this includes updating the utilities, doing a spring cleanup, and maybe even building a new addition. But taking care of a home also includes the often not-so-pretty maintenance work. Is there a leaky pipe causing water damage? The kitchen sink is running brown, so could this be related to a pipe issue? Now there’s mold under the shingles, the floorboards have started to creak, and the AC doesn’t want to start. There are more questions than answers and solutions can seem helplessly out of reach.
Managing any project, from game development to homeownership, requires due diligence to ensure that all parts are working as intended. This can be a daunting challenge; when issues stem from some underlying breakpoint, how do you fix what you can’t see? Ultimately, there is no other way to identify and remedy the root of an issue than to lift the outer shell. When the inner workings are exposed—and more importantly, understood—solutions are made clear.
When taking care of a house, you can equip yourself with the right tools to diagnose any issue at hand and help prevent any issues in the future. Perhaps you want to attach a TV to the wall but you don’t know where the studs are. Avert a crisis by using a stud finder to locate the best anchor points.
Likewise, for graphics development, it is vital that you feel empowered to handle any bug fix or optimization need that could arise. Just like any other project, having the right tools enables this.
What are developer tools?
Good developer tools are like an x-ray machine that allows you to peek into the internals of the GPU. There is always some layer of abstraction between the physical computer and the application that you are building, but you can’t optimize and debug what you can’t see. Developer tools grant visibility to hardware-level processes and expose the computing that drives graphics on the screen.
By revealing activity metrics like GPU throughput and identifying slowdowns like frame stutters, developer tools help ensure your final product is performant, optimized, and well-made. Simultaneously, tools offer speed-ups to development time by eliminating time sinks caused by uninformed bug fixing.
Figure 1. GPU Trace hardware metrics
Something has clearly failed when the output on the screen does not align with your intentions. When you’re coding, an error is returned when a line doesn’t work. However, flags aren’t automatically raised for code that could be written a little more performantly or with a few more optimizations.
The same can be said for graphics development. When frame rates suddenly drag or scene loading lingers too long, it is futile to guess-and-check answers without going under the hood to profile issues at the hardware origin. By providing low-level insights to inform debugging, developer tools help eliminate the need to brute-force solutions.
Tools can also help handle a more dramatic case: when there is no output on the screen. A GPU crash can halt graphics processes in an abrupt, confounding way. In the era of massively programmable GPUs, you can write custom shading methods, and memory access is built to be immediate and direct. These features enable stylistic variety with speedy processing, but also new opportunities for errors to trigger a crash. Having access to hardware state at the moment of failure is critical in remedying a GPU exception.
Figure 2. Heat-map showing areas with performance issues
What is Nsight?
NVIDIA Nsight Developer Tools are the suite of tools that provide the most direct and comprehensive access to NVIDIA GPUs and the low-level code that interfaces with them. Nsight provides critical information for performance tuning and optimizations that you would normally not have access to.
NVIDIA graphics cards are complex and can do amazing things when fully utilized. This point grows in scale with each new GPU generation, markedly so for the NVIDIA Ada Lovelace architecture. The Nsight suite of tools helps ensure your application is capturing the full potential of the GPU processing power.
This is particularly true when developing NVIDIA RTX–enabled apps and games. Nsight Graphics offers in-depth graphics debugging for both ray-traced and rasterized applications. It exposes inefficiencies in the rendering pipeline and makes optimizations easy to find through clear visuals, like the GPU trace and frame analysis.
If you are looking to access GPU performance metrics live and in-application, you can use the Nsight Perf SDK, which features a real-time HUD solution that monitors GPU activity.
For a system-wide approach to performance tuning, Nsight Systems profiles GPU throughput in parallel with CPU performance and other metrics including network and memory operations. By providing a top-down capture of these workloads, performance limiters can be identified and correlated with other hardware events to guide tuning activities at the source.
To handle an unexpected GPU crash, which can be one of the most frustrating hindrances to any developer, the Nsight Aftermath SDK generates detailed pipeline dumps that identify source code where an error occurred.
The are many more Nsight Developer Tools to explore that could be relevant to your development field. Nsight also includes a collection of CUDA compute tools, including Nsight Compute for CUDA kernel profiling. For more information about the breadth of tools available, see NVIDIA Developer Tools Overview.
Figure 3. NetEase used NVIDIA Nsight Developer Tools to help them prepare Justice Online, their martial arts MMORPG, for the GeForce RTX 40 series
Get started with Nsight Developer Tools
Nsight tools has extended support to the NVIDIA Ada Lovelace architecture. To learn about how Nsight tools uplift game development on the newest generation GPU, see the following videos.
Video 1. Building Games with NVIDIA Nsight Tools on NVIDIA Ada Lovelace
Video 2. NVIDIA Development Tools: Walkthrough of Development Scenarios and Solutions
Alien invasions. Gritty dystopian megacities. Battlefields swarming with superheroes. As one of Hollywood’s top concept artists, Drew Leung can visualize any world you can think of, except one where AI takes his job. He would know. He’s spent the past few months trying to make it happen, testing every AI tool he could. “If your Read article >
NVIDIA and Oracle are teaming to make the power of AI accessible to enterprises across industries. These include healthcare, financial services, automotive and a broad range of natural language processing use cases driven by large language models, such as chatbots, personal assistants, document summarization and article completion. Join NVIDIA and Oracle experts at Oracle CloudWorld, Read article >
High-end PC gaming arrives on more devices this GFN Thursday. GeForce NOW RTX 3080 members can now stream their favorite PC games at up to 1600p and 120 frames per second in a Chrome browser. No downloads, no installs, just victory. Even better, NVIDIA has worked with Google to support the newest Chromebooks, which are Read article >
NVIDIA is excited to introduce a new feature available in the next generation of GPUs called Shader Execution Reordering (SER). SER is a performance…
NVIDIA is excited to introduce a new feature available in the next generation of GPUs called Shader Execution Reordering (SER). SER is a performance optimization that unlocks the potential for better ray and memory coherency in ray tracing shaders, and thus increased shading efficiency.
Background and overview
Shading divergence is a long-standing problem in ray tracing. With increasingly complex renderer implementations, more workloads are becoming limited by shader execution rather than the tracing of rays. One way to mitigate this problem is to reduce the divergence affecting the GPU when executing shader code.
SER helps to alleviate two types of divergence: execution divergence and data divergence. Execution divergence occurs when different threads execute different shaders or branches within a shader. Data divergence occurs when different threads access memory resources in patterns that are hard to cache.
SER mitigates divergence by reordering threads, on the fly, across the GPU so that they can continue execution with increased coherence. It also enables the decoupling of ray intersection and shading.
HLSL extension headers, which can be found in the latest NVIDIA API
Link against nvapi64.lib, included in the packages containing the headers above
A recent version of DXC / dxcompiler.dll that supports templates (optional). If you’re compiling shaders from Visual Studio, make sure that your project is configured to use this version of the compiler executable.
First, initialize / deinitialize NVAPI using the following call:
NvAPI_Initialize();
NvAPI_Unload();
Next, verify that the SER API is supported, using the following call:
bool supported = false;
NvAPI_D3D12_IsNvShaderExtnOpCodeSupported(pDevice, NV_EXTN_OP_HIT_OBJECT_REORDER_THREAD, &supported);
if (!supported)
{
/* Don't use SER */
}
Host side integration
Before ray tracing state object creation, set up a fake UAV slot and register it:
#define NV_SHADER_EXTN_SLOT 999999 // pick an arbitrary unused slot
#define NV_SHADER_EXTN_REGISTER_SPACE 999999 // pick an arbitrary unused space
NvAPI_D3D12_SetNvShaderExtnSlotSpace(pDevice, NV_SHADER_EXTN_SLOT,
NV_SHADER_EXTN_REGISTER_SPACE);
If you need a thread-local variant, use the related function: NvAPI_D3D12_SetNvShaderExtnSlotSpaceLocalThread.
Next, add the fake UAV slot to the global root signature used to compile ray tracing pipelines. You do not need to allocate and / or bind a resource for this. Below is an example of augmenting D3D12 sample code with a fake UAV slot, denoted in bold. The root signature creation in your application will likely look quite different.
// Global Root Signature
// This is a root signature that is shared across all raytracing shaders invoked during a
// DispatchRays() call.
{
// Performance TIP: Order from most frequent to least frequent.
CD3DX12_DESCRIPTOR_RANGE ranges[5];
ranges[0].Init(D3D12_DESCRIPTOR_RANGE_TYPE_UAV, 1, 0); // output texture
ranges[1].Init(D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 2, 0, 1); // static index buffers
ranges[2].Init(D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 2, 0, 2); // static vertex buffers
ranges[3].Init(D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 1, 0, 3); // static vertex buffers
// fake UAV for shader execution reordering
ranges[4].Init(
D3D12_DESCRIPTOR_RANGE_TYPE_UAV, 1, NV_SHADER_EXTN_SLOT, NV_SHADER_EXTN_REGISTER_SPACE);
CD3DX12_ROOT_PARAMETER rootParameters[GlobalRootSignatureParams::Count];
rootParameters[GlobalRootSignatureParams::OutputViewSlot].InitAsDescriptorTable(1, &ranges[0]);
rootParameters[GlobalRootSignatureParams::AccelerationStructureSlot].InitAsShaderResourceView(0);
rootParameters[GlobalRootSignatureParams::SceneConstantSlot].InitAsConstantBufferView(0);
rootParameters[GlobalRootSignatureParams::VertexBuffersSlot].InitAsDescriptorTable(3, &ranges[1]);
rootParameters[GlobalRootSignatureParams::SerUavSlot].InitAsDescriptorTable(1, &ranges[4]);
CD3DX12_ROOT_SIGNATURE_DESC globalRootSignatureDesc(ARRAYSIZE(rootParameters), rootParameters);
SerializeAndCreateRaytracingRootSignature(
globalRootSignatureDesc, &m_raytracingGlobalRootSignature);
}
Use of API in shader code
In shader code, define the fake UAV slot and register again, using the same values:
#define NV_SHADER_EXTN_SLOT u999999 // matches slot number in NvAPI_D3D12_SetNvShaderExtnSlotSpace
#define NV_SHADER_EXTN_REGISTER_SPACE space999999 // matches space number in NvAPI_D3D12_SetNvShaderExtnSlotSpace
#include "SER/nvHLSLExtns.h"
Now the SER API may be used in ray generation shaders:
1) ensure that templates are enabled in DXC by specifying the command line argument -HV 2021
or
2) use the macro version of the API that does not require templates. The macro version can be enabled by #defining NV_HITOBJECT_USE_MACRO_API before #including nvHLSLExtns.h. This is intended for use in legacy codebases which have difficulty switching to HLSL 2021. The recommended path is using templates if the codebase can support it.
Integration of Unreal Engine 5 NvRTX
Unreal Engine developers can take advantage of SER within the NVIDIA branch of Unreal Engine (NvRTX). The following section explains how SER provides performance gains in ray tracing operations and provides optimization tips for specific use cases.
The NVIDIA Unreal Engine 5 NvRTX 5.0.3 release will feature SER integration to support optimization of many of its ray tracing paths. With SER, NvRTX developers will see additional frame rate optimization on 40 series cards with up to 40% increased speeds in ray tracing operations and zero impact on quality or content authoring. This improves efficiency of complex ray tracing calculations and will provide greater gains in scenes that take full advantage of what ray tracing has to offer.
Benefits of SER in Unreal Engine 5
SER in Unreal Engine 5 (UE5) enables better offline path tracing, arguably the most complex tracing operation in UE5. Likewise, hardware ray traced reflections and translucency, which have complex interactions with materials and lighting, will also see benefits.
SER also improves Lumen performance when hardware ray tracing is enabled. In some cases, the changes required to do this, independent of initial system complexity, are trivial. In other cases, it has added substantial complexity. Three different examples are explored in more detail below.
Simple case: Path tracing
Path tracing presents a highly divergent workflow, making it a great candidate for applying SER.
Figure 1. Grandma’s Kitchen by Richard Cowgill, path traced in Unreal Engine 5. Path tracing is 40% faster with SER for this view.
Applying SER allows the path tracer to reduce divergence in its material evaluation, instead of just on the number of bounces. This offers a 20-50% gain in performance with the code change provided below:
#if !PATH_TRACER_USE_REORDERING
// Trace the ray, including evaluation of hit data
TraceRay(
TLAS,
RayFlags,
RAY_TRACING_MASK_ALL,
RAY_TRACING_SHADER_SLOT_MATERIAL,
RAY_TRACING_NUM_SHADER_SLOTS,
MissShaderIndex,
PathState.Ray,
PackedPayload);
#else
{
NvHitObject Hit;
// Trace ray to produce hit object
NvTraceRayHitObject(
TLAS,
RayFlags,
RAY_TRACING_MASK_ALL,
RAY_TRACING_SHADER_SLOT_MATERIAL,
RAY_TRACING_NUM_SHADER_SLOTS,
MissShaderIndex,
PathState.Ray,
PackedPayload, Hit);
// Reorder threads to have coherent hit evaluation
NvReorderThread(Hit);
// Evaluate hit data in the now coherent environment
NvInvokeHitObject(TLAS, Hit, PackedPayload);
}
#endif
This improvement can be accomplished by replacing the DXR TraceRay function with an equivalent set of NvTraceRayHitObject, NvReorderThread, and NvInvokeHitObject. A key aspect is that the optimization is only applied selectively. The change only applies to the TraceTransparentRay function within the UE5 path tracing code, as this is the source of most material evaluation divergence. Other rays are performing cheaper operations and are less important to reorder, so they may not be worth the extra cost of attempting to reorder.
This example is the tip of the iceberg when it comes to the potential of the path tracer code. More careful analysis will almost certainly allow additional gains, including possibly eliminating the need to use multiple passes to compact longer rays.
Unusual case: Work compaction in Lumen global illumination
Typically, one thinks of reordering to handle the execution divergence experienced by hit shading. While the ray tracing passes used in Lumen global illumination do not run a divergent hit shader, they still benefit from the mechanisms provided by SER.
For large scenes, like the UE5 City Sample, traces are broken into the near and far field, which are run as separate tracing passes with compaction in between. The multiple passes and compaction can be replaced by a single NVReorderThread call. This avoids the idle bubbles on the GPU required to compact the results of near-field tracing, and then launch far-field rays.
Removing the extra overhead of storing, compacting, and relaunching work is often worth a 20% savings. The shader changes can be more intensive due to assumptions in the original code (functions using macros to permute behaviors rather than arguments). However, the logical changes amounted to adding two reorder calls with a single Boolean expression for whether a trace had hit or missed.
Complex case: Lumen reflections
Lumen is a system contained in UE5 which implements global illumination and reflections. It has a high degree of complexity, and a thorough discussion of it is well beyond the scope of this blog post. The description below is heavily distilled and focuses on one specific configuration: Lumen reflections with hardware ray tracing (HWRT) hit lighting enabled. Note that Lumen is also able to leverage software ray tracing by way of signed distance fields, which will not be discussed here.
To render reflections, the Lumen HWRT hit lighting path uses multiple passes:
Near field tracing – extract material ID
Compact rays
Far field tracing (optional) – extract material ID
Compact rays
Append far field rays (optional)
Sort rays by material
Re-trace with hit lighting
In addition, the following important details about how Lumen works help explain the differences in approach between SER and non-SER.
Near field and far field in lumen correspond with different sections of the TLAS for objects close to the camera, and objects far away from the camera respectively. Both near field and far field are contained in the same TLAS.
Two different ray tracing pipelines are used in the passes above. Near and far field both use a simplified (fast) tracing path, while hit lighting has full material support. This is the reason for the separate re-tracing path with hit lighting.
For further technical details on these passes, see Lumen Technical Details. With SER enabled, the passes can be combined because separate compaction and sorting phases are no longer necessary. The pass roughly becomes trace near field, if not a hit trace far field, if either hit then uses the hit object to evaluate the material and perform lighting. This is possible due to the decoupling of tracing and shading.
The relevant sections of the shader are provided below:
NvHitObject SERHitObject;
// Near field
NvTraceRayHitObject(..., SERHitObject);
NvReorderThread(SERHitObject);
Result.bIsHit = SERHitObject.IsHit();
// Far field
if (!Result.bIsHit)
{
// Transform ray into far field space of TLAS
...
NvTraceRayHitObject(..., SERHitObject);
NvReorderThread(SERHitObject);
Result.bIsHit = SERHitObject.IsHit();
}
// Compute result
if (Result.bIsHit)
{
NvInvokeHitObject(Context.TLAS, SERHitObject, Payload);
Result.Radiance = CalculateRayTracedLighting();
}
// Handle miss
This is one example of the availability of SER creating a higher-level implication on the rendering architecture, rather than just replacing TraceRay with the respective NVAPI equivalent. The implementation described above resulted in a 20-30% speed increase in Lumen reflections on the GPU, measured when profiling a typical workload in UE5 City Sample.
Conclusion
Shading divergence can pose performance problems when considering both data and execution. The Shader Execution Reordering API gives developers a powerful tool to mitigate these penalties, with relatively little effort required to get started. The optimizations discussed above represent only the initial stages of introducing the possibilities provided by SER to a large codebase, such as Unreal Engine 5. We look forward to seeing SER realize more of its potential as its use evolves.
The age of electric vehicles has arrived and, with it, an entirely new standard for premium SUVs. Polestar, the performance EV brand spun out from Volvo Cars, launched its third model today in Copenhagen. With the Polestar 3, the automaker has taken SUV design back to the drawing board, building a vehicle as innovative as Read article >
Career-related questions are common during NVIDIA cybersecurity webinars and GTC sessions. How do you break into the profession? What experience do you need?…
Learn to detect data abnormalities before they impact your business by using XGBoost, autoencoders, and GANs.
When developing on NVIDIA platforms, the hardware should be transparent to you. GPUs can feel like magic, but in the interest of optimized and performant games,…
Learn how to train the largest of deep neural networks and deploy them to production.
NVIDIA is excited to introduce a new feature available in the next generation of GPUs called Shader Execution Reordering (SER). SER is a performance…
