Is it ok to call AhoCorasick in lazy_static?

[Guillermogsjc]

Is it ok to use

use aho_corasick::{AhoCorasick, AhoCorasickBuilder, MatchKind};

fn my_func_using_ac(text: &str) -> String{
  lazy_static! {
          static ref AC_INSTANCE: AhoCorasick = AhoCorasickBuilder::new()
              .match_kind(MatchKind::LeftmostLongest)
              .build(["foo"]);
  }
AC_INSTANCE.replace_all(text, &["bar"])
}

and then use my_func_using_ac anywhere, potentially in several threads similarly to regex:Regex usage?

[BurntSushi]

Yes. Did you have any specific concerns with it?

[Guillermogsjc]

some objects in regex lib have caches that are not "suited for" threading as read from somewhere in doc.

There is in documentation the use case of regex compiled inside lazy_static, just wanted to confirm that it is ok to do the same with AhoCorasick

Thanks.

[BurntSushi]

The regex lib is absolutely suited for use from multiple threads. That's why the docs suggest using lazy_static (or once_cell, which is the more recent hotness). The issue here is that:

• The internal regex engines need mutable space to execute searches. So some kind of synchronization is needed here.
• The approach this library takes is to have a pool of mutable space that can be plucked out in a thread safe way. If multiple threads need to execute the same regex at the same time, then multiple copies of the space are created. They just need to coordinate when they pluck things out of the pool, but otherwise they're free to go on their own.

So, if you have a lot of threads trying to run the same regex at the same time, then you might be able to observe some of the overhead that comes from contention from accessing the pool. But this generally only happens when you're searching a lot of very tiny haystacks.

This is probably the doc you're referring to, which explains this in more detail: https://github.com/rust-lang/regex/blob/master/PERFORMANCE.md#using-a-regex-from-multiple-threads

Bottom line though is that this is only an issue if, well, it's an issue. You can profile your program and look at whether it's spending a lot of time accessing the pool.

AhoCorasick does not use any mutable space during a search. So if you're just using an AhoCorasick searcher directly, there is no explicit synchronization happening whatsoever.