CodeMirror/czkawka
1
0
Fork 0
mirror of synced 2024-05-17 19:03:08 +12:00
Code Issues Projects Releases Wiki Activity

Atomic counter

Browse source
This commit is contained in:
Rafał Mikrut 2023-05-01 20:39:13 +02:00
parent e16c28a2e9
commit f826d72f60
8 changed files with 58 additions and 58 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
czkawka_core/src/bad_extensions.rs
View file

@ -325,12 +325,12 @@ impl BadExtensions {
//// PROGRESS THREAD START
let progress_thread_run = Arc::new(AtomicBool::new(true));
let atomic_file_counter = Arc::new(AtomicUsize::new(0));
let atomic_counter = Arc::new(AtomicUsize::new(0));
let progress_thread_handle = prepare_thread_handler_common(
progress_sender,
&progress_thread_run,
&atomic_file_counter,
&atomic_counter,
1,
1,
self.files_to_check.len(),
@ -350,7 +350,7 @@ impl BadExtensions {
hashmap_workarounds.entry(found).or_insert_with(Vec::new).push(proper);
}
self.bad_extensions_files = self.verify_extensions(files_to_check, &atomic_file_counter, stop_receiver, &check_was_stopped, &hashmap_workarounds);
self.bad_extensions_files = self.verify_extensions(files_to_check, &atomic_counter, stop_receiver, &check_was_stopped, &hashmap_workarounds);
// End thread which send info to gui
progress_thread_run.store(false, Ordering::Relaxed);
@ -374,7 +374,7 @@ impl BadExtensions {
fn verify_extensions(
&self,
files_to_check: Vec<FileEntry>,
atomic_file_counter: &Arc<AtomicUsize>,
atomic_counter: &Arc<AtomicUsize>,
stop_receiver: Option<&Receiver<()>>,
check_was_stopped: &AtomicBool,
hashmap_workarounds: &HashMap<&str, Vec<&str>>,
@ -382,7 +382,7 @@ impl BadExtensions {
files_to_check
.into_par_iter()
.map(|file_entry| {
atomic_file_counter.fetch_add(1, Ordering::Relaxed);
atomic_counter.fetch_add(1, Ordering::Relaxed);
if stop_receiver.is_some() && stop_receiver.unwrap().try_recv().is_ok() {
check_was_stopped.store(true, Ordering::Relaxed);
return None;

16
czkawka_core/src/big_file.rs
View file

@ -152,16 +152,16 @@ impl BigFile {
&self,
progress_sender: Option<&futures::channel::mpsc::UnboundedSender<ProgressData>>,
progress_thread_run: &Arc<AtomicBool>,
atomic_file_counter: &Arc<AtomicU64>,
atomic_counter: &Arc<AtomicU64>,
) -> JoinHandle<()> {
if let Some(progress_sender) = progress_sender {
let progress_send = progress_sender.clone();
let progress_thread_run = progress_thread_run.clone();
let atomic_file_counter = atomic_file_counter.clone();
let atomic_counter = atomic_counter.clone();
thread::spawn(move || loop {
progress_send
.unbounded_send(ProgressData {
files_checked: atomic_file_counter.load(Ordering::Relaxed) as usize,
files_checked: atomic_counter.load(Ordering::Relaxed) as usize,
})
.unwrap();
if !progress_thread_run.load(Ordering::Relaxed) {
@ -185,8 +185,8 @@ impl BigFile {
}
let progress_thread_run = Arc::new(AtomicBool::new(true));
let atomic_file_counter = Arc::new(AtomicU64::new(0));
let progress_thread_handle = self.prepare_thread_handler(progress_sender, &progress_thread_run, &atomic_file_counter);
let atomic_counter = Arc::new(AtomicU64::new(0));
let progress_thread_handle = self.prepare_thread_handler(progress_sender, &progress_thread_run, &atomic_counter);
while !folders_to_check.is_empty() {
if stop_receiver.is_some() && stop_receiver.unwrap().try_recv().is_ok() {
@ -239,7 +239,7 @@ impl BigFile {
if metadata.is_dir() {
self.check_folder_children(&mut dir_result, &mut warnings, current_folder, &entry_data);
} else if metadata.is_file() {
self.collect_file_entry(&atomic_file_counter, &metadata, &entry_data, &mut fe_result, &mut warnings, current_folder);
self.collect_file_entry(&atomic_counter, &metadata, &entry_data, &mut fe_result, &mut warnings, current_folder);
}
}
(dir_result, warnings, fe_result)
@ -297,14 +297,14 @@ impl BigFile {
pub fn collect_file_entry(
&self,
atomic_file_counter: &Arc<AtomicU64>,
atomic_counter: &Arc<AtomicU64>,
metadata: &Metadata,
entry_data: &DirEntry,
fe_result: &mut Vec<(u64, FileEntry)>,
warnings: &mut Vec<String>,
current_folder: &Path,
) {
atomic_file_counter.fetch_add(1, Ordering::Relaxed);
atomic_counter.fetch_add(1, Ordering::Relaxed);
if metadata.len() == 0 {
return;

12
czkawka_core/src/broken_files.rs
View file

@ -241,8 +241,8 @@ impl BrokenFiles {
//// PROGRESS THREAD START
let progress_thread_run = Arc::new(AtomicBool::new(true));
let atomic_file_counter = Arc::new(AtomicUsize::new(0));
let progress_thread_handle = self.prepare_thread_handler_broken_files(progress_sender, &progress_thread_run, &atomic_file_counter, 0, 1, 0);
let atomic_counter = Arc::new(AtomicUsize::new(0));
let progress_thread_handle = self.prepare_thread_handler_broken_files(progress_sender, &progress_thread_run, &atomic_counter, 0, 1, 0);
//// PROGRESS THREAD END
@ -319,7 +319,7 @@ impl BrokenFiles {
dir_result.push(next_folder);
} else if metadata.is_file() {
atomic_file_counter.fetch_add(1, Ordering::Relaxed);
atomic_counter.fetch_add(1, Ordering::Relaxed);
let file_name_lowercase: String = match entry_data.file_name().into_string() {
Ok(t) => t,
@ -443,13 +443,13 @@ impl BrokenFiles {
}
let progress_thread_run = Arc::new(AtomicBool::new(true));
let atomic_file_counter = Arc::new(AtomicUsize::new(0));
let progress_thread_handle = self.prepare_thread_handler_broken_files(progress_sender, &progress_thread_run, &atomic_file_counter, 1, 1, non_cached_files_to_check.len());
let atomic_counter = Arc::new(AtomicUsize::new(0));
let progress_thread_handle = self.prepare_thread_handler_broken_files(progress_sender, &progress_thread_run, &atomic_counter, 1, 1, non_cached_files_to_check.len());
let mut vec_file_entry: Vec<FileEntry> = non_cached_files_to_check
.into_par_iter()
.map(|(_, mut file_entry)| {
atomic_file_counter.fetch_add(1, Ordering::Relaxed);
atomic_counter.fetch_add(1, Ordering::Relaxed);
if stop_receiver.is_some() && stop_receiver.unwrap().try_recv().is_ok() {
return None;
}

12
czkawka_core/src/duplicate.rs
View file

@ -655,11 +655,11 @@ impl DuplicateFinder {
let check_was_stopped = AtomicBool::new(false); // Used for breaking from GUI and ending check thread
let progress_thread_run = Arc::new(AtomicBool::new(true));
let atomic_file_counter = Arc::new(AtomicUsize::new(0));
let atomic_counter = Arc::new(AtomicUsize::new(0));
let progress_thread_handle = prepare_thread_handler_common(
progress_sender,
&progress_thread_run,
&atomic_file_counter,
&atomic_counter,
1,
2,
self.files_with_identical_size.values().map(Vec::len).sum(),
@ -716,7 +716,7 @@ impl DuplicateFinder {
let mut errors: Vec<String> = Vec::new();
let mut buffer = [0u8; 1024 * 2];
atomic_file_counter.fetch_add(vec_file_entry.len(), Ordering::Relaxed);
atomic_counter.fetch_add(vec_file_entry.len(), Ordering::Relaxed);
for file_entry in vec_file_entry {
if stop_receiver.is_some() && stop_receiver.unwrap().try_recv().is_ok() {
check_was_stopped.store(true, Ordering::Relaxed);
@ -800,12 +800,12 @@ impl DuplicateFinder {
let start_time: SystemTime = SystemTime::now();
//// PROGRESS THREAD START
let progress_thread_run = Arc::new(AtomicBool::new(true));
let atomic_file_counter = Arc::new(AtomicUsize::new(0));
let atomic_counter = Arc::new(AtomicUsize::new(0));
let progress_thread_handle = prepare_thread_handler_common(
progress_sender,
&progress_thread_run,
&atomic_file_counter,
&atomic_counter,
2,
2,
pre_checked_map.values().map(Vec::len).sum(),
@ -866,7 +866,7 @@ impl DuplicateFinder {
let mut errors: Vec<String> = Vec::new();
let mut buffer = [0u8; 1024 * 16];
atomic_file_counter.fetch_add(vec_file_entry.len(), Ordering::Relaxed);
atomic_counter.fetch_add(vec_file_entry.len(), Ordering::Relaxed);
for mut file_entry in vec_file_entry {
if stop_receiver.is_some() && stop_receiver.unwrap().try_recv().is_ok() {
check_was_stopped.store(true, Ordering::Relaxed);

26
czkawka_core/src/same_music.rs
View file

@ -360,12 +360,12 @@ impl SameMusic {
//// PROGRESS THREAD START
let progress_thread_run = Arc::new(AtomicBool::new(true));
let atomic_file_counter = Arc::new(AtomicUsize::new(0));
let atomic_counter = Arc::new(AtomicUsize::new(0));
let progress_thread_handle = if let Some(progress_sender) = progress_sender {
let progress_send = progress_sender.clone();
let progress_thread_run = progress_thread_run.clone();
let atomic_file_counter = atomic_file_counter.clone();
let atomic_counter = atomic_counter.clone();
let music_to_check = non_cached_files_to_check.len();
thread::spawn(move || loop {
progress_send
@ -373,7 +373,7 @@ impl SameMusic {
checking_method: CheckingMethod::None,
current_stage: 1,
max_stage: 2,
entries_checked: atomic_file_counter.load(Ordering::Relaxed),
entries_checked: atomic_counter.load(Ordering::Relaxed),
entries_to_check: music_to_check,
})
.unwrap();
@ -391,7 +391,7 @@ impl SameMusic {
let mut vec_file_entry = non_cached_files_to_check
.into_par_iter()
.map(|(path, mut music_entry)| {
atomic_file_counter.fetch_add(1, Ordering::Relaxed);
atomic_counter.fetch_add(1, Ordering::Relaxed);
if stop_receiver.is_some() && stop_receiver.unwrap().try_recv().is_ok() {
check_was_stopped.store(true, Ordering::Relaxed);
return None;
@ -530,12 +530,12 @@ impl SameMusic {
//// PROGRESS THREAD START
let progress_thread_run = Arc::new(AtomicBool::new(true));
let atomic_file_counter = Arc::new(AtomicUsize::new(0));
let atomic_counter = Arc::new(AtomicUsize::new(0));
let progress_thread_handle = if let Some(progress_sender) = progress_sender {
let progress_send = progress_sender.clone();
let progress_thread_run = progress_thread_run.clone();
let atomic_file_counter = atomic_file_counter.clone();
let atomic_counter = atomic_counter.clone();
let music_to_check = self.music_to_check.len();
thread::spawn(move || loop {
progress_send
@ -543,7 +543,7 @@ impl SameMusic {
checking_method: CheckingMethod::None,
current_stage: 2,
max_stage: 2,
entries_checked: atomic_file_counter.load(Ordering::Relaxed),
entries_checked: atomic_counter.load(Ordering::Relaxed),
entries_to_check: music_to_check,
})
.unwrap();
@ -562,7 +562,7 @@ impl SameMusic {
if (self.music_similarity & MusicSimilarity::TRACK_TITLE) == MusicSimilarity::TRACK_TITLE {
for vec_file_entry in old_duplicates {
atomic_file_counter.fetch_add(1, Ordering::Relaxed);
atomic_counter.fetch_add(1, Ordering::Relaxed);
if stop_receiver.is_some() && stop_receiver.unwrap().try_recv().is_ok() {
// End thread which send info to gui
progress_thread_run.store(false, Ordering::Relaxed);
@ -590,7 +590,7 @@ impl SameMusic {
}
if (self.music_similarity & MusicSimilarity::TRACK_ARTIST) == MusicSimilarity::TRACK_ARTIST {
for vec_file_entry in old_duplicates {
atomic_file_counter.fetch_add(1, Ordering::Relaxed);
atomic_counter.fetch_add(1, Ordering::Relaxed);
if stop_receiver.is_some() && stop_receiver.unwrap().try_recv().is_ok() {
// End thread which send info to gui
progress_thread_run.store(false, Ordering::Relaxed);
@ -618,7 +618,7 @@ impl SameMusic {
}
if (self.music_similarity & MusicSimilarity::YEAR) == MusicSimilarity::YEAR {
for vec_file_entry in old_duplicates {
atomic_file_counter.fetch_add(1, Ordering::Relaxed);
atomic_counter.fetch_add(1, Ordering::Relaxed);
if stop_receiver.is_some() && stop_receiver.unwrap().try_recv().is_ok() {
// End thread which send info to gui
progress_thread_run.store(false, Ordering::Relaxed);
@ -643,7 +643,7 @@ impl SameMusic {
}
if (self.music_similarity & MusicSimilarity::LENGTH) == MusicSimilarity::LENGTH {
for vec_file_entry in old_duplicates {
atomic_file_counter.fetch_add(1, Ordering::Relaxed);
atomic_counter.fetch_add(1, Ordering::Relaxed);
if stop_receiver.is_some() && stop_receiver.unwrap().try_recv().is_ok() {
// End thread which send info to gui
progress_thread_run.store(false, Ordering::Relaxed);
@ -668,7 +668,7 @@ impl SameMusic {
}
if (self.music_similarity & MusicSimilarity::GENRE) == MusicSimilarity::GENRE {
for vec_file_entry in old_duplicates {
atomic_file_counter.fetch_add(1, Ordering::Relaxed);
atomic_counter.fetch_add(1, Ordering::Relaxed);
if stop_receiver.is_some() && stop_receiver.unwrap().try_recv().is_ok() {
// End thread which send info to gui
progress_thread_run.store(false, Ordering::Relaxed);
@ -693,7 +693,7 @@ impl SameMusic {
}
if (self.music_similarity & MusicSimilarity::BITRATE) == MusicSimilarity::BITRATE {
for vec_file_entry in old_duplicates {
atomic_file_counter.fetch_add(1, Ordering::Relaxed);
atomic_counter.fetch_add(1, Ordering::Relaxed);
if stop_receiver.is_some() && stop_receiver.unwrap().try_recv().is_ok() {
// End thread which send info to gui
progress_thread_run.store(false, Ordering::Relaxed);

16
czkawka_core/src/similar_images.rs
View file

@ -304,18 +304,18 @@ impl SimilarImages {
//// PROGRESS THREAD START
let progress_thread_run = Arc::new(AtomicBool::new(true));
let atomic_file_counter = Arc::new(AtomicUsize::new(0));
let atomic_counter = Arc::new(AtomicUsize::new(0));
let progress_thread_handle = if let Some(progress_sender) = progress_sender {
let progress_send = progress_sender.clone();
let progress_thread_run = progress_thread_run.clone();
let atomic_file_counter = atomic_file_counter.clone();
let atomic_counter = atomic_counter.clone();
thread::spawn(move || loop {
progress_send
.unbounded_send(ProgressData {
current_stage: 0,
max_stage: 3,
images_checked: atomic_file_counter.load(Ordering::Relaxed),
images_checked: atomic_counter.load(Ordering::Relaxed),
images_to_check: 0,
})
.unwrap();
@ -402,7 +402,7 @@ impl SimilarImages {
dir_result.push(next_folder);
} else if metadata.is_file() {
atomic_file_counter.fetch_add(1, Ordering::Relaxed);
atomic_counter.fetch_add(1, Ordering::Relaxed);
let file_name_lowercase: String = match entry_data.file_name().into_string() {
Ok(t) => t,
@ -529,19 +529,19 @@ impl SimilarImages {
let check_was_stopped = AtomicBool::new(false); // Used for breaking from GUI and ending check thread
let progress_thread_run = Arc::new(AtomicBool::new(true));
let atomic_file_counter = Arc::new(AtomicUsize::new(0));
let atomic_counter = Arc::new(AtomicUsize::new(0));
let progress_thread_handle = if let Some(progress_sender) = progress_sender {
let progress_send = progress_sender.clone();
let progress_thread_run = progress_thread_run.clone();
let atomic_file_counter = atomic_file_counter.clone();
let atomic_counter = atomic_counter.clone();
let images_to_check = non_cached_files_to_check.len();
thread::spawn(move || loop {
progress_send
.unbounded_send(ProgressData {
current_stage: 1,
max_stage: 3,
images_checked: atomic_file_counter.load(Ordering::Relaxed),
images_checked: atomic_counter.load(Ordering::Relaxed),
images_to_check,
})
.unwrap();
@ -558,7 +558,7 @@ impl SimilarImages {
let mut vec_file_entry: Vec<(FileEntry, Vec<u8>)> = non_cached_files_to_check
.into_par_iter()
.map(|(_s, mut file_entry)| {
atomic_file_counter.fetch_add(1, Ordering::Relaxed);
atomic_counter.fetch_add(1, Ordering::Relaxed);
if stop_receiver.is_some() && stop_receiver.unwrap().try_recv().is_ok() {
check_was_stopped.store(true, Ordering::Relaxed);
return None;

16
czkawka_core/src/similar_videos.rs
View file

@ -269,18 +269,18 @@ impl SimilarVideos {
//// PROGRESS THREAD START
let progress_thread_run = Arc::new(AtomicBool::new(true));
let atomic_file_counter = Arc::new(AtomicUsize::new(0));
let atomic_counter = Arc::new(AtomicUsize::new(0));
let progress_thread_handle = if let Some(progress_sender) = progress_sender {
let progress_send = progress_sender.clone();
let progress_thread_run = progress_thread_run.clone();
let atomic_file_counter = atomic_file_counter.clone();
let atomic_counter = atomic_counter.clone();
thread::spawn(move || loop {
progress_send
.unbounded_send(ProgressData {
current_stage: 0,
max_stage: 1,
videos_checked: atomic_file_counter.load(Ordering::Relaxed),
videos_checked: atomic_counter.load(Ordering::Relaxed),
videos_to_check: 0,
})
.unwrap();
@ -367,7 +367,7 @@ impl SimilarVideos {
dir_result.push(next_folder);
} else if metadata.is_file() {
atomic_file_counter.fetch_add(1, Ordering::Relaxed);
atomic_counter.fetch_add(1, Ordering::Relaxed);
let file_name_lowercase: String = match entry_data.file_name().into_string() {
Ok(t) => t,
@ -486,19 +486,19 @@ impl SimilarVideos {
let check_was_stopped = AtomicBool::new(false); // Used for breaking from GUI and ending check thread
let progress_thread_run = Arc::new(AtomicBool::new(true));
let atomic_file_counter = Arc::new(AtomicUsize::new(0));
let atomic_counter = Arc::new(AtomicUsize::new(0));
let progress_thread_handle = if let Some(progress_sender) = progress_sender {
let progress_send = progress_sender.clone();
let progress_thread_run = progress_thread_run.clone();
let atomic_file_counter = atomic_file_counter.clone();
let atomic_counter = atomic_counter.clone();
let videos_to_check = non_cached_files_to_check.len();
thread::spawn(move || loop {
progress_send
.unbounded_send(ProgressData {
current_stage: 1,
max_stage: 1,
videos_checked: atomic_file_counter.load(Ordering::Relaxed),
videos_checked: atomic_counter.load(Ordering::Relaxed),
videos_to_check,
})
.unwrap();
@ -514,7 +514,7 @@ impl SimilarVideos {
let mut vec_file_entry: Vec<FileEntry> = non_cached_files_to_check
.par_iter()
.map(|file_entry| {
atomic_file_counter.fetch_add(1, Ordering::Relaxed);
atomic_counter.fetch_add(1, Ordering::Relaxed);
if stop_receiver.is_some() && stop_receiver.unwrap().try_recv().is_ok() {
check_was_stopped.store(true, Ordering::Relaxed);
return None;

8
czkawka_core/src/temporary.rs
View file

@ -146,18 +146,18 @@ impl Temporary {
//// PROGRESS THREAD START
let progress_thread_run = Arc::new(AtomicBool::new(true));
let atomic_file_counter = Arc::new(AtomicUsize::new(0));
let atomic_counter = Arc::new(AtomicUsize::new(0));
let progress_thread_handle = if let Some(progress_sender) = progress_sender {
let progress_send = progress_sender.clone();
let progress_thread_run = progress_thread_run.clone();
let atomic_file_counter = atomic_file_counter.clone();
let atomic_counter = atomic_counter.clone();
thread::spawn(move || loop {
progress_send
.unbounded_send(ProgressData {
current_stage: 0,
max_stage: 0,
files_checked: atomic_file_counter.load(Ordering::Relaxed),
files_checked: atomic_counter.load(Ordering::Relaxed),
})
.unwrap();
if !progress_thread_run.load(Ordering::Relaxed) {
@ -243,7 +243,7 @@ impl Temporary {
dir_result.push(next_folder);
} else if metadata.is_file() {
atomic_file_counter.fetch_add(1, Ordering::Relaxed);
atomic_counter.fetch_add(1, Ordering::Relaxed);
let file_name_lowercase: String = match entry_data.file_name().into_string() {
Ok(t) => t,