permit skipping .lafl_lock files

[Vincebye]

• Add lafl_lock attribute to structure InMemoryOnDiskCorpus
• Add no_lafl_lock function
• The default attribute lafl_true=true is added to the _new function
• Rename_testcase and save_testcase increase the judgment of lafl_lock attribute

[Vincebye]

#1129

[domenukk]

The docs should clearly state that this will be racey if multiple cores work on the same corpus.

Maybe I'd even rename this function multicore_unsafeor similar. The fact that lafl_lock files are produced is just an impelmentation detail imho, what do you think?

[Vincebye]

I think the .lafl_lock file is needed if working on multi-core. In some cases, if there is no competition problem for a single core, the user is allowed not to generate the .lafl_lock file, so I did not consider the competition problem without generating the .lafl_lock file.

[domenukk]

Ah actually if you still create a file (and just not name it .lafl_lock(), you will not be racey, the only issue is that we may produce empty files if we quit. I initially thought you would not check if the file exists, at all..
Interesting.
What's your use case then?

[Vincebye]

I don't quite understand why an empty file is generated. I have experimented with the code locally and it will not affect the file generation.

use std::fs::OpenOptions;
use std::{thread, env};



fn create(){
    let mut ctr = 1;
    let mut file_name="file".to_owned();
    let new_file_name = loop {
        let file_path=env::current_dir().unwrap().join(&file_name);
        println!("111Trying with file name: {:?}", file_path);
        if OpenOptions::new()
            .write(true)
            .create_new(true)
            .open(&file_path)
            .is_ok()
        {
            println!("File created: {:?}", file_path);
            break file_name;
        }
        println!("File already exists: {:?}", file_path);
        let new_name=format!("{}-{}",file_name,ctr);
        file_name = new_name;
        println!("Trying with new file name: {:?}", file_name);
        ctr += 1;
    };
}




fn main() {
    let mut handles = vec![];
    
    for i in 0..5 {
        handles.push(thread::spawn(move || {
            create();
        }));
    }
    for handle in handles {
        handle.join().unwrap();
    }
}

[domenukk]

I think the main reason for the lockfile was that this way, you never end up using the same file twice, from two threads. Like, before moving the file, writing it, removing it, or something like that, you'd create the lock file.
But I'm not 100% sure if it's really needed/has benefits.