C++ Move vs Copy a local stl container to a list inside a loop - copy

Question

In the lower fictitious code example (C++17) I ask myself whether I should optimize here with std::move or better not. The last emplace_back seems to be a suitable candidate, since "idsLocal" is certainly no longer needed afterwards. With the first emplace_back I wonder if that would make sense here. If I move "idsLocal" there and call the clear() afterwards, I avoid the copy, but I am feared that "idsLocal" would potentially have to reallocate multiple times again in the next iterations (memory is moved?!), which it probably wouldn't have done otherwise because of the reserve-call. So would I have an advantage here (and why) if I use std::move everywhere in the emplace_back-calls? My time measurements were very fluctuating and did not really give a clear result for me.
For example, let's take the following input data for divideIntoIdsList:
=> "limit" is 1024 and we have 5120 different id's
Naively thought, the following could come out:
Without move in the FIRST emplace_back:
-> 1 malloc(s) for the reserve at idsLocal
-> 5 malloc(s) for copying idsLocal 5 times in idsList
With move in the FIRST emplace_back:
-> 1 malloc(s) for the reserve at idsLocal
-> 0 malloc(s) for moving idsLocal 5 times in idsList (?)
-> 40 malloc(s) for dynamic resizes in idsLocal beginning
after the first move (4 x 10 push_back's per limit) (?)
Assuming that allocations are expensive, would the
move variant be even slower?
Code-Example:
#include <list>
#include <numeric>
#include <vector>
template < class T >
auto divideIntoIdsList( size_t limit, const T &ids, std::list< T > &idsList )
{
if ( ids.empty() )
return;
T idsLocal;
idsLocal.reserve( limit );
size_t iIdCount=0;
for( typename T::const_iterator itIds = ids.begin();
itIds != ids.end(); ++itIds )
{
idsLocal.push_back( *itIds );
if( ++iIdCount == limit )
{
idsList.emplace_back( idsLocal ); //std::move(idsLocal) here?!
idsLocal.clear();
iIdCount=0;
}
}
if( iIdCount > 0 )
idsList.emplace_back( idsLocal ); //std::move(idsLocal) here seems useful
}
int main()
{
using ids_t = std::vector< size_t >;
ids_t ids( 5120 );
std::iota( std::begin( ids ), std::end( ids ), 0 );
std::list< ids_t > idslist;
divideIntoIdsList( 1024, ids, idslist );
return 0;
}