Somewhat-hardware-conscious algorithm for top k-of-n with $k=\Omega(\sqrt{n})$
If you're allowed to make multiple passes through the data, one efficient approach is to use QuickSelect to find the value of the $k$-th largest element, then follow with a linear scan that outputs all elements that are larger than it.

This is more or less a more carefully-worked out version of the kind of approach you seemed to be considering.

See also https://en.wikipedia.org/wiki/Selection_algorithm.



The following approach was written for an earlier version of the question, which specified $k = O(\sqrt{n})$, but might not be useful for large $k$:

Another possible approach would be to take a sorting network, which is a hardware circuit that sorts all of the values.  Then, throw away all but the last $k$ outputs, and keep only the gates they depend on.  You might be able to throw away a non-trivial fraction of the sorting network -- I haven't tried to work out how much.  This would solve the partial sorting network, and could potentially be hardware-friendly.



The following approach was written for an earlier version of the question, which specified $k = O(\sqrt{n})$, but might not be useful for large $k$:

Another approach is to do something like merge sort, but where you only keep the top $k$ elements in each list at each stage.  In other words, split your data so that each processor receives an equal number of items.  Have each processor find the top $k$ of its elements (say, using a priority queue or any other method).  Then merge lists recursively, where each merge operation merges two or more lists of size $k$ and outputs only the first (largest) $k$ elements of the result.  This might work very well for out-of-cache (too-large-to-fit-in-main-memory) situations, or for parallel computing.  If you can fit $B$ items in cache/memory, then each merge step merges $B/k$ lists, so the number of rounds is $\lg_{B/k} (n/B)$.