There are two main components to the time it takes to process a draw call:
The time it takes to calculate all the results for every work item in the batch
The time it takes to upload info / switch states / ready the GPU to start working on it
As GPUs have gotten more powerful, most of the leaps and bounds have helped with point 1. They can now run hundreds of work items in parallel at blazing speeds, chewing through huge batches of geometry and shaded fragments.
They've gotten faster at point 2. as well, but the gains there are less dramatic because the work is often serial. If two draw calls issued back-to-back need different global state, in some cases the GPU has to wait for the previous call to finish completely before it can safely change that state and start working on the next call - even if it has hundreds of threads sitting idle in the meantime. This is called a pipeline flush.
So generally, we want to go wide as much as we can - give the GPU big jobs that can fill up all its threads, so it's never stuck waiting on work. Most games try to avoid unnecessary draw calls, and send their drawing instructions in big batches whenever they can.
So usually, one 100 k poly mesh is likely to render faster than 1000 100-poly meshes.
But wait, isn't that at odds with this advice?
"If you have a lot of objects in your scene, then each mesh must have low polygon count"
Lots of models (ie. lots of separate draw calls) each needing very little work (few polygons) is the opposite of what modern GPUs are good at!
But Unity knows that GPUs prefer to work on big batches (and also that manually combining models together into a batch is a pain for developers), so it has some strategies to handle this for you.
If the engine notices that you have a lot of objects that use the same material (ie. same shader, parameters, and other pipeline state), then it will try to pack them together into a batch to send to the GPU as though they were one big mesh. It can do this both statically - combining meshes marked "static" in your scenes when you build your game - and dynamically - analyzing your dynamic meshes each frame and packing them as best it can to save draw calls at runtime.
This can be expensive to do optimally, so Unity has some strict limits in how much geometry it will try to process this way. It will only try to batch an object if it has no more than 300 vertices, and no more than 900 vertex attributes in total (eg. vertex position, normal, uv)
So, this is what the advice is telling you about:
- If you have a lot of models in your scene, the draw call switching costs can be high
- You can reduce the number of draw calls by combining the models into batches
- Unity will do this for you, but only if your models are quite small