Is there a disadvantage to that, i.e. having the application memory consisting of multiple chunks at addresses further away from each other then what could theoretically be achieved if all application memory was allocated as one big chunk?
You will have to:
look at what is virtual and physical memory, and how they are mapped.
see if caching is done at virtual or physical layer on your architecture.
see how your OS does things
Does fragmented physical memory matter?
Only if it results in more complex virtual to physical maps (mmu, etc)
A contiguous virtual block with non contiguous physical, may result in a much more complex lookup map. Linux has various page sizes that it can use, it will try to use the biggest it can (to best match the malloc). On my system Debian jessie with kernel 4.6.0-0 amd64, I have page sizes of 4k (154964 in use), 2M (3753 in use) and 1G (1 in use).
Does fragmented virtual memory matter?
I can not see that it does, if the process requested several blocks with multiple malocs, then it will see them as separate, even if adjacent. One maloc must be contiguous in virtual. The security system, may but guard blocks between each maloced block, thus preventing them being adjacent.
On Linux a lot will be shared between processes:
If the same executable file, then they will share all read-only blocks of the executable (text, data-ro, etc). They will also share initialised data (data), until one of them changes a page, then this page is copied.
The same is done for all the dynamic linked libraries, so they will share a lot of these. Also the files on disk are the swap for this memory, so it will not bother reading in the data until it needs it (the program will start to run with none of it read in, this will result in a ram miss, and a page being read in, then the program will run, until there is another miss etc etc). If there is a lack of ram the a page can be dropped, it can be read again latter (no need to swap it out). This could cause a lot of disk reads when memory is low, resulting in slower start up. If processes are started separately, then the 2nd process putting pressure on the memory subsystem, will cause unused pages to be dropped (probably pages that were used at start up of process 1, but have not been used since).
(some architectures cache physical memory: this is the most obvious. Others cache virtual memory: this can result in the same physical memory being cached twice. This is wasteful, but simpler and faster. Some architectures do both e.g virtual caching at level 1, where it needs to be fast, physical caching at other levels where it needs to be memory efficient. ).