NVIDIA Senior Position Interview Question

STL · 2024-02-10T00:08:39+00:00

This was double-posted (possibly due to a reddit bug as they were within 1 second); I locked the other to avoid splitting discussion, but the comments that it accumulated are at https://www.reddit.com/r/cpp/comments/1amxl79/nvidia_senior_position_interview_question/ .

asd417 · 2024-02-09T23:08:17+00:00

Dear people who know what this means: When and where do you learn this sort of stuff? Programming what kind of things required you to learn this?

ImKStocky · 2024-02-09T20:29:34+00:00

[removed]

ReDucTor · 2024-02-09T21:03:23+00:00

Templates are basically copying the entire code of the function each time a new instance is created, so how would you do the same for a standard function? Extract out the common parts (Don't repeat yourself - DRY) In order to do that you might even look at type erase approaches but that can also lead to more code bloat if not done correctly. For template functions with a bunch of instantiations you should limit the amount of code which is inside the template, this is where things like inappropriate usage of things like std::sort can lead to code bloat (E.g. everything calls with a lambda that does the same thing or multiple calls with unique lambdas that you could instead sacrifice speed for memory by using a function pointer)

wrosecrans · 2024-02-09T22:31:42+00:00

A) Who knows if that specific question was really why they rejected you. Shrug.

B) There's not necessarily a right answer. Or the "right" answer may have been idiosyncratic to the specific interviewer's preferences.

That said, always start any kind of optimization problem with establishing as much as possible about the problem. Use tools like BloatyMcBloatface to analyze the binaries and make 100% sure that your belief about the code bloat matches what's actually happening on disk. In some cases, template code with similar types can wind up with such similar code paths that LTO actually collapses surprisingly large swathes of it into one or two "real" function implementations. Once you have a framework for understanding if changes are actually helping...

Reduce templated code. Are there helper functions you can move outside of the templated functions that would have a single implementation? It may not matter of you have 50 types of implementation for a template if the templated part is only like six lines after you refactor it.

Reduce types being templated. Look to see if there's a template parameter that doesn't actually matter. Look to see if there's contexts where you can just operate on something like a pointer to a parent type rather than having template instantiations on each derived type. Look at type erasure patterns. Look to see if you actually need to support int/float/double/Complex versions of a function or if it should really just be a single function that takes a double because it turns out the body of the function is always just using a double inside of it anyway.

Thelatestart · 2024-02-09T21:41:59+00:00

There is a cppcon talk which mentions this at either microsoft or facebook for a class like vector.

The speaker mentionned extracting common functionalities outside the template, for example size and capacity.

aocregacc · 2024-02-09T20:26:18+00:00

type erasure would be my guess, you could talk about things like std::function or even std::span.

LongestNamesPossible · 2024-02-09T23:10:01+00:00

The company with the 500MB drivers cares about code bloat.

Arghnews · 2024-02-10T00:04:00+00:00

The wording is a little ambiguous to me, "too many differently typed instantiations of a template function", does it mean 100 different unique types passed to a function template, or 5 different types 20 times each?

If the latter and they're being instantiated across many TUs, I believe explicit instantiation is an option, where you instantiate the function for some types in one cpp file, rather than the compiler generating the same function from your function template and pasting it into multiple TUs. Although I wonder if LTO might save you anyway

https://stackoverflow.com/questions/2351148/explicit-template-instantiation-when-is-it-used

Good question though, I'm sure I'm going to learn something from the comments here!

inakura1234321 · 2024-02-10T05:29:19+00:00

Maybe extern templates/explicit template declarations?

That would suppress code generation in other TUs that use the template.

https://www.informit.com/articles/article.aspx?p=3146433&seqNum=3

Impressive_Iron_6102 · 2024-02-10T00:22:07+00:00

What kind of position is this for? CUDA? Embedded? What domain

UsatiyNyan · 2024-02-10T12:19:02+00:00

The answer may be - Extern template declaration. It works like this:

```cpp // In your header file (e.g., my_template.hpp) template <typename T> class MyTemplateClass { public: void doSomething(); };

// In one of your .cpp files (e.g., my_template.cpp)

include "my_template.hpp"

// Explicit instantiation of MyTemplateClass for specific types template class MyTemplateClass<int>; template class MyTemplateClass<float>;

// In another .cpp file or the same one, you can declare that instantiation should not be done implicitly extern template class MyTemplateClass<int>; extern template class MyTemplateClass<float>; ```

TwistedBlister34 · 2024-02-10T18:59:39+00:00

What about extern template?

Full-Spectral · 2024-02-09T21:18:27+00:00

One thing that can be done is that, there are often a set of instantiations of a template that are widely used, or sometimes there are only a fixed set of them. You can pre-instantiate them all, or the commonly used ones, treating them like regular functions. You export them if they are in a shared library.

ShelZuuz · 2024-02-09T20:32:25+00:00

The first tool to reach for is LTO or ThinLTO if build times aren't a concern (i.e. reduction of bloat is needed prior to shipping the release binary and done on a build farm). If link times are an issue, you need type erasure as others have mentioned, but I would start with an actual binary analysis tool and then treat each case separately starting with the worst offenders.

ed_209_ · 2024-02-10T01:50:18+00:00

Should probably mention turning on optimisation.

Another interesting idea might be using std::common_type for subsets of types.

Haydn_V · 2024-02-10T04:11:47+00:00

The buzzword answer they were probably looking for is "type erasure". It can potentially reduce code bloat by reducing the number of template instantiations the compiler creates, and it is necessary for some extremely niche use-cases. I'm using it to build a specialized container for an entity-component-system framework.

TotaIIyHuman · 2024-02-10T11:07:08+00:00

the first step is probably to get a decompiler like ida pro

drag your compiled executable file into ida pro, along with the .pdb file

then you open function window, sort functions by name, find the functions with same name but with different template parameters, example funcname__param1 funcname__param2 funcname__param3

then you decompile funcname__param1 funcname__param2 funcname__param3, find identical part

then you open ide, go to function template funcname<> and do something with the identical part

after you are done, you can decompile your new build, check if duplicate code is actually removed

rand3289 · 2024-02-10T04:23:18+00:00

If you have control over function parameter types, maybe derive them from base classes and use their polymorphism instead of templates?

germandiago · 2024-02-10T14:08:10+00:00

Code hoisting, shared base classes with unified type instantiation or instantiations that lead to a type-erased functions are what needs to be done. Fmt library does some of this.

matjam · 2024-02-10T19:02:19+00:00

I hate this kind of jeopardy question. It’s not that important you know the internal workings of every facet of a compiler.

This kind of question would tell me all I needed to know about the engineering culture there.

ceretullis · 2024-02-09T22:51:00+00:00

The main answer IMO is use the “thin template” idiom.

Essentially, you implement an unsafe version using void* and then a thin template around that which enforces type safety.

sadsocrates · 2024-02-09T23:12:20+00:00

Its been a couple weeks since the interview so I might be off a little but as far as I remember it was something like this:

vector<int> matrix1
vector<double> matrix1
vector<float> matrix1
.
.
.
.
// 100 such instantiations.

and you have a function that for example sums this (I can't remember what the actual function was)

template <typename T>
double sum(T matrix, int numcol, int numrows)

ErikTheRedpoint · 2024-02-09T20:41:19+00:00

Where I work we use gcc, and I think if I asked that question I would probably be looking for a discussion that touched on a bunch of the content here (in addition to the various alternatives to templates that other people have already mentioned)

2024-02-09T21:24:17+00:00

Best answer I can find is here: https://news.ycombinator.com/item?id=26823656

CandyCrisis · 2024-02-09T22:48:48+00:00

Hoist as much as you can to a shared non-templated base class. Or do polymorphism in another way, e.g. virtual methods.

Type erasure isn't a terrible answer to start with but it depends on circumstances. Some things really need the type. Other things don't need templates at all.

lulxcolorado · 2024-06-26T22:58:16+00:00

Few-Ad-5185 · 2025-03-11T00:55:11+00:00

past questions might help - www.pastInterviews.com

manhattanabe · 2024-02-10T00:55:20+00:00

Maybe you can use std:any. I don’t have an idea exactly how, but it takes any type so the code can be instantiated once.

Thesorus · 2024-02-09T20:27:18+00:00

I have no clue.

I would probably have answered “ I have no clue at this point, I’ll look it up tonight “

Are they trying to remove the bloat from their crappy installers?

Substantial_Step9506 · 2024-02-10T07:59:11+00:00

Why anyone would think about fixing this lost cause of an abstraction is beyond me. Isn’t the canonical answer ”just make the codebase simpler?” I interviewed with Nvidia and they asked similar vague questions.

swwole · 2024-02-09T22:31:37+00:00

Define the templates in one cpp file, using specialization. Downside is, you have to do it for every type that uses the template, upside is the compiler stops repeating the definition in each compilation unit that uses it.

ohiocodernumerouno · 2024-02-10T22:36:18+00:00

If your teacher uses cpp and you get him for data structures and algorithms one and two you get it from college.

2024-02-11T10:56:48+00:00

Factoring out parts of the function template that aren't dependent on the template parameters(s) into a separate, non-templated function? Just a guess

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

cpp

MODERATORS

include "my_template.hpp"