How to release gcs::Client resources

[shaileshkm]

Hi,

My code encapsulates google::cloud::StatusOr<gcs::Client> object.
I construct is using default constructor.
StatusOr() : StatusOr(Status(StatusCode::kUnknown, "default")) {}

During authentication, I reset it with
_client_wrapper = gcs::Client(gcs::ClientOptions(*creds));

I need to hold the object across multiple read/write operations that may be invoked in multiple threads.

How should I release the previous instance of client in such case?
In rare case, I may need to authenticate again, that may overwrite the object.

Even if I don't overwrite the object, our code's memory allocation gear reports memory leak of 192 bytes with above bare bone operations.

[coryan]

Think of gcs::Client as a std::shared_ptr<>: copying them is "cheap", also, two copies pointing to the same shared state can be used from two different threads, i.e., this is safe:

void F(gcs::Client a) {
  std::thread t([](gcs::Client b) { /* use b */, a);
  a = ...;
  t.join();
}

but this is not:

void NotSafe(gcs::Client a) {
  std::thread t([](gcs::Client& b) { /* use b */, std::ref(a));
  a = ...; // not safe..
  t.join();
}

With that out of the way:

Even if I don't overwrite the object, our code's memory allocation gear reports memory leak of 192 bytes with above bare bone operations.

Does it say where? It could be a bug that our memory allocation stuff does not detect, or it could be a false positive. FWIW, we mostly use AddressSanitizer to check for memory leaks, but I have used valgrind from time-to-time.

[shaileshkm]

Sorry, my question wasn't about thread safety. Thanks for the example though.

I want to understand how the object resources can be freed/released before I overwrite the object.

[coryan]

Sorry, my question wasn't about thread safety. Thanks for the example though.

Ack.

I want to understand how the object resources can be freed/released before I overwrite the object.

The first part was my attempt at answering this: a gcs::Client is like a std::shared_ptr<>. If you use it as a value type there should be no leaks.

Of course we could have a bug bug somewhere. Or maybe the "memory allocation gear" you refer to is showing false positives, that is, things that look like leaks, but are not, or are a constant one-time cost of initialization.