Hello, 
Jeeedeee's code is great but it misses a important scenario which generate chunk: If in your list of sObject you have more than 200 records of the same object it will generate one chunk per 200 records. E.g: you have 1600 A, 50 B, 50 C and 50 D you will reach 10 chunk limit even with 4 objects.

I modified a bit Jeeedeee's code to cover this use case:

private static void saveSobjectSet(List <Sobject> listToUpdate) {
        Integer SFDC_CHUNK_LIMIT = 10;
        
        // Developed this part due to System.TypeException: Cannot have more than 10 chunks in a single operation
        Map<String, List<Sobject>> sortedMapPerObjectType = new Map<String, List<Sobject>>();
        Map<String, Integer> numberOf200ChunkPerObject = new Map<String, Integer>();
        for (Sobject obj : listToUpdate) {
            String objTypeREAL = String.valueOf(obj.getSObjectType());
            
            if (! numberOf200ChunkPerObject.containsKey(objTypeREAL)){
                numberOf200ChunkPerObject.put(objTypeREAL, 1);
            }
            // Number of 200 chunk for a given Object
            Integer numnberOf200Record = numberOf200ChunkPerObject.get(objTypeREAL);
            // Object type + number of 200 records chunk
            String objTypeCURRENT = String.valueOf(obj.getSObjectType()) + String.valueOf(numnberOf200Record);
            // CurrentList
            List<sObject> currentList = sortedMapPerObjectType.get(objTypeCURRENT);
            
            if (currentList == null || currentList.size() > 199) {
               if(currentList != null && currentList.size() > 199){
                    numberOf200ChunkPerObject.put(objTypeREAL, numnberOf200Record + 1);
                    objTypeCURRENT = String.valueOf(obj.getSObjectType()) + String.valueOf(numnberOf200Record);            
                }
                sortedMapPerObjectType.put(objTypeCURRENT, new List<Sobject>());
            }
            sortedMapPerObjectType.get(objTypeCURRENT).add(obj);
        }
        while(sortedMapPerObjectType.size() > 0) {
            // Create a new list, which can contain a max of chunking limit, and sorted, so we don't get any errors 
            List<Sobject> safeListForChunking = new List<Sobject>();
            List<String> keyListSobjectType = new List<String>(sortedMapPerObjectType.keySet());
            for (Integer i = 0;i<SFDC_CHUNK_LIMIT && !sortedMapPerObjectType.isEmpty();i++) {
                List<Sobject> listSobjectOfOneType = sortedMapPerObjectType.remove(keyListSobjectType.remove(0)); 
                safeListForChunking.addAll(listSobjectOfOneType);
            }
            
            update safeListForChunking;
        }
    }

It might not be the best optimization, I'm happy to take comments on this.

Hope it helps.