Add helper function for rate-limiting progress messages

[wimlib] / src / write.c

diff --git a/src/write.c b/src/write.c
index 5bd8db911e1e275b40f5cd236d760fadf395674e..47579b549c5a8123f872b5f7bc8b19652e60f5dd 100644 (file)
--- a/src/write.c
+++ b/src/write.c
@@ -300,8 +300,8 @@ do_write_blobs_progress(struct write_blobs_progress_data *progress_data,
                progress->write_streams.completed_streams += complete_count;
        }
 
-       if (progress->write_streams.completed_bytes >= progress_data->next_progress)
-       {
+       if (progress->write_streams.completed_bytes >= progress_data->next_progress) {
+
                ret = call_progress(progress_data->progfunc,
                                    WIMLIB_PROGRESS_MSG_WRITE_STREAMS,
                                    progress,
@@ -309,32 +309,9 @@ do_write_blobs_progress(struct write_blobs_progress_data *progress_data,
                if (ret)
                        return ret;
 
-               if (progress_data->next_progress == progress->write_streams.total_bytes) {
-                       progress_data->next_progress = ~(u64)0;
-               } else {
-                       /* Handle rate-limiting of messages  */
-
-                       /* Send new message as soon as another 1/128 of the
-                        * total has been written.  (Arbitrary number.)  */
-                       progress_data->next_progress =
-                               progress->write_streams.completed_bytes +
-                                       progress->write_streams.total_bytes / 128;
-
-                       /* ... Unless that would be more than 5000000 bytes, in
-                        * which case send the next after the next 5000000
-                        * bytes.  (Another arbitrary number.)  */
-                       if (progress->write_streams.completed_bytes + 5000000 <
-                           progress_data->next_progress)
-                               progress_data->next_progress =
-                                       progress->write_streams.completed_bytes + 5000000;
-
-                       /* ... But always send a message as soon as we're
-                        * completely done.  */
-                       if (progress->write_streams.total_bytes <
-                           progress_data->next_progress)
-                               progress_data->next_progress =
-                                       progress->write_streams.total_bytes;
-               }
+               set_next_progress(progress->write_streams.completed_bytes,
+                                 progress->write_streams.total_bytes,
+                                 &progress_data->next_progress);
        }
        return 0;
 }
@@ -654,8 +631,8 @@ do_done_with_blob(struct blob_descriptor *blob,
        inode = blob->file_inode;
 
        wimlib_assert(inode != NULL);
-       wimlib_assert(inode->num_remaining_streams > 0);
-       if (--inode->num_remaining_streams > 0)
+       wimlib_assert(inode->i_num_remaining_streams > 0);
+       if (--inode->i_num_remaining_streams > 0)
                return 0;
 
 #ifdef __WIN32__
@@ -795,7 +772,7 @@ write_blob_uncompressed(struct blob_descriptor *blob, struct filedes *out_fd)
        if (filedes_seek(out_fd, begin_offset) == -1)
                return 0;
 
-       ret = extract_full_blob_to_fd(blob, out_fd);
+       ret = extract_blob_to_fd(blob, out_fd);
        if (ret) {
                /* Error reading the uncompressed data.  */
                if (out_fd->offset == begin_offset &&
@@ -1333,19 +1310,13 @@ finish_remaining_chunks(struct write_blobs_ctx *ctx)
 }
 
 static void
-remove_empty_blobs(struct list_head *blob_list)
+validate_blob_list(struct list_head *blob_list)
 {
-       struct blob_descriptor *blob, *tmp;
+       struct blob_descriptor *blob;
 
-       list_for_each_entry_safe(blob, tmp, blob_list, write_blobs_list) {
+       list_for_each_entry(blob, blob_list, write_blobs_list) {
                wimlib_assert(blob->will_be_in_output_wim);
-               if (blob->size == 0) {
-                       list_del(&blob->write_blobs_list);
-                       blob->out_reshdr.offset_in_wim = 0;
-                       blob->out_reshdr.size_in_wim = 0;
-                       blob->out_reshdr.uncompressed_size = 0;
-                       blob->out_reshdr.flags = reshdr_flags_for_blob(blob);
-               }
+               wimlib_assert(blob->size != 0);
        }
 }
 
@@ -1367,7 +1338,7 @@ init_done_with_file_info(struct list_head *blob_list)
 
        list_for_each_entry(blob, blob_list, write_blobs_list) {
                if (blob_is_in_file(blob)) {
-                       blob->file_inode->num_remaining_streams = 0;
+                       blob->file_inode->i_num_remaining_streams = 0;
                        blob->may_send_done_with_file = 1;
                } else {
                        blob->may_send_done_with_file = 0;
@@ -1376,7 +1347,7 @@ init_done_with_file_info(struct list_head *blob_list)
 
        list_for_each_entry(blob, blob_list, write_blobs_list)
                if (blob->may_send_done_with_file)
-                       blob->file_inode->num_remaining_streams++;
+                       blob->file_inode->i_num_remaining_streams++;
 }
 
 /*
@@ -1504,7 +1475,7 @@ write_blob_list(struct list_head *blob_list,
                                (WRITE_RESOURCE_FLAG_SOLID |
                                 WRITE_RESOURCE_FLAG_PIPABLE));
 
-       remove_empty_blobs(blob_list);
+       validate_blob_list(blob_list);
 
        if (list_empty(blob_list))
                return 0;
@@ -1615,13 +1586,11 @@ write_blob_list(struct list_head *blob_list,
        /* Read the list of blobs needing to be compressed, using the specified
         * callbacks to execute processing of the data.  */
 
-       struct read_blob_list_callbacks cbs = {
-               .begin_blob             = write_blob_begin_read,
-               .begin_blob_ctx         = &ctx,
-               .consume_chunk          = write_blob_process_chunk,
-               .consume_chunk_ctx      = &ctx,
-               .end_blob               = write_blob_end_read,
-               .end_blob_ctx           = &ctx,
+       struct read_blob_callbacks cbs = {
+               .begin_blob     = write_blob_begin_read,
+               .consume_chunk  = write_blob_process_chunk,
+               .end_blob       = write_blob_end_read,
+               .ctx            = &ctx,
        };
 
        ret = read_blob_list(blob_list,
@@ -2751,9 +2720,9 @@ write_wim_part(WIMStruct *wim,
        if (write_flags & WIMLIB_WRITE_FLAG_RETAIN_GUID)
                guid = wim->hdr.guid;
        if (guid)
-               memcpy(wim->out_hdr.guid, guid, WIMLIB_GUID_LEN);
+               copy_guid(wim->out_hdr.guid, guid);
        else
-               randomize_byte_array(wim->out_hdr.guid, WIMLIB_GUID_LEN);
+               generate_guid(wim->out_hdr.guid);
 
        /* Set the part number and total parts.  */
        wim->out_hdr.part_number = part_number;