ZMQ | libzmq Perl binding

If the actual $pc value does not match the start of a line (according to the line table within the debug information), then GDB will print the $pc before printing the line number, and source line.

That's what's going on here. For line 31 GDB stopped at the exact address for the start of line 31, and so no address was printed.

For the line 30 output, which, like you said, is almost certainly the destructor call, the address we are now at 0x00007ffe1fc6b36b is associated with line 30, but is not the start of that line, and so, GDB prints the address.

The important thing to understand here, is that when GDB prints something like:

I just installed the lower version of RDKit and it worked fine.

Q :
_{" What does this mean, and how can I fix it? "}

A :
The MEANING : Spyder is to be blamed (except where WSL fail to emulate ipc: over W10 pipe)
and REMEDY : check for more recent updates, if available & notify Spyder developers to do a better self-healing code-design, that uses ZeroMQ best-practices to unlock and release all resources they setup internally in due tiame and fashion ( no offense, just be also informed that some recent ZeroMQ native API default might cause another level of code-refactoring, as assumed-only behaviours have started to fail (self)-execute after a new, other default value starts to turn such use of implicit-only-logic upside down - zmq.LINGER being one such potential cause for indefinite hanging zmq.PUSH-socket, instead of being .close()-ed, right due to such zmq.LINGER-related behaviour.

Spyder & similar IDE tools started to heavily use ZeroMQ internally many years ago, which -for obvious reasons- started to cause problems (not only when users instantiated own ZeroMQ Context()-s) colliding in using localhost resources. As internal Spyder crashes keep appearin (some salvageable with console/IDE soft-reset(s), some not) some Spyder's usage of ZeroMQ resources was not in all cases programmed in a robust-enough, self-healing manner -- some of internal crashes did indeed leave some of the ZeroMQ resources hung (as you've seen above). Reboot sometimes being the only way one had to resort to, so as to finally release'em

Q :
_{Is it safe to use inproc://* between a thread and asyncio task in this way?""}

A :
First and foremost, I might be awfully wrong (not only here), yet having worked with ZeroMQ since native API 2.1.1+ I dare claim that unless newer "improvements" got lost the core principles ( ZeroMQ ZMTP/RFC-documented properties for building legal implementation of the still valid ZMTP-arsenal ), the answer here shall be YES, as much as the newer releases of pyzmq-binding kept all mandatory properties of the inproc:-Transport-Class without a compromise.

Q :
_{" The 0MQ context is thread safe and I'm not sharing sockets between the thread and the asyncio task, so I would say in general that this is thread safe, right? "}

A :
Here my troubles start - ZeroMQ implementations were since ever developed based on Martin SUSTRIK's & Pieter HINTJENS' Zen-of-Zero -- i.e. also as Zero-sharing -- so never sharing was the principle ( though "share"-zmq.Context-instances were no problem to be used from different threads, to the contrary of the zmq.Socket-instances )

Python (since ever & still valid in 2022-Q1) used to use & still uses a total [CONCURRENT]-code-execution avoider -- prevented by GIL-lock, which principally avoids any & all kinds of problems, arising from [CONCURRENT]-code-execution to never happen insider Python GIL-lock re-[SERIAL]-ised flow of code-execution, so even if the asyncio-part is built as a pythonic (non-destructive) part of the ecosystem, your code shall never "meet" any kind of concurrency-related issue, as the unless it gains GIL-lock, it does nothing but "hanging in NOP-s cracking" ( nuts-cracking in idle loop ).

Being inside the same process, there seems no advantage to spawn another Context-instance at all ( this used to be the rock-solid certainty since ever, not to ever increase any kind of overheads - Zen-of-Zero _{( almost )}Zero-overhead ... ). The Sig/Msg core engine was, if performance or latency needs required, powered with more zmq.Context( IOthreads ) upon instantiations, yet these were zmq.Context-owned, not Python-GIL-governed/(b)locked threads, so the performance was pretty well scalable, without wasting any RAM/HWM/buffers/...-resources, without growing any overheads and very efficient, as the IO-threads were co-located for only indeed I/O-work, so not needed for inproc:-( protocol-less )-Transport-Class at all )

Q :
_{" Or am I missing something that I should consider? "}

A :
Mixing asyncio, O/S-signals ( that are well documented how they interact with native ZeroMQ API ) and other layers of complexity is for sure possible, yet it comes at a cost - it makes the use-case less and less readable and more and more prone to conceptual-gaps and similar hard to decode "errors".

I remember using Tkinter-mainloop() as a cost-wise very cheap and a super-stable framework for rapid-prototyping an MVC-{ M-odel, V-isual, C-ontroller }-parts of many-actors' indeed distributed-system applications in Python. There were Zerop-problems to use ZeroMQ with a single Context-instance, passing the references of the respective AccessNodes' into whatever amount of event-handlers, supposing we kept the ZeroMQ Zen-of-Zero, i.e. no to "share" (meaning no two parts "use" (compete to use) one and the same AccessPoint "one-over-another")

This all was designed-in, at "Zero-cost", by the ZeroMQ by-definition, so unless spoilt in some later phase, re-wrapping a re-wrapped native API, all this ought still work in 2022-Q1, ought it not?

Q : "How to check ZMQ publisher is alive or not in c# ?"

A :
There are at least two ways to do so :

• a )
  modify the code on both the PUB-side and SUB-side, so that the Publisher sends both the PUB/SUB-channel messages, and independently of that also PUSH/PULL-keep-alive messages to prove to the SUB-side it is still alive, as being autonomously received as confirmations from the PULL-AccessPoint on the SUB-side loop. Not receiving such soft-keep-alive message for some time may trigger the SUB-side loop to become sure to break. The same principle may get served by a reversed PUSH/PULL-channel, where SUB-side, from time to time, asks the PUB-side, listening on the PULL-side, using asynchronously sent soft-request message to inject a soft-keep-alive message into the PUB-channel ( remember the TOPIC-filter is a plain ASCII-filtering from the left to the right of the message-payload, so PUSH-delivered message could as easily send the exact text to be looped-back via PUB/SUB back to the sender, matching the locally known TOPIC-filter maintained by the very same SUB-side entity )

• b )
  in cases, where you cannot modify the PUB-side code, we still can setup a time-based counter, after expiring which, without receiving a single message ( be it using a loop of a known multiple of precisely timed-aSUB.poll( ... )-s, which allows for a few, priority-ordered interleaved control-loops to be operated without uncontrolled mutual blocking, or by using a straight, non-blocking form of aSUB.recv( zmq.NOBLOCK ) aligned within the loop with some busy-loop avoiding, CPU-relieving sleep()-s ). In case such timeout happens, having received no actual message so far, we can autonomously break the SUB-side loop, as requested above.

Q.E.D.

The problem is the default shape used for the VGG19 model. You can try replacing the input shape and applying a Flatten layer just before the output layer. Here is a working example:

Using the header files does not say anything about where the actual shared object file is present. You must add -lzmq (or whatever the library is called) to your linker flags in the project.

The easiest way is to create a makefrag file in the source folder (where the Makefile is generated) and add

Let me share a view on how ZeroMQ could meet the above defined Intention.

Let's rather use ZeroMQ Scalable Formal Communication Pattern Archetypes ( as they are RTO now, not as we may wish them to be at some, yet unsure, point in (a just potentially happening) future evolution state ).

We need not hesitate to use many more ZeroMQ-based connections among a herd of coming/leaving client-instance(s) and the server

For example :

Client .connect()-s a REQ-socket to Server-address:port-A to ask for a "job"-ticket processing over this connection

Client .connect()-s a SUB-socket to Server-address:port-B to listen ( if present ) about published announcements about already completed "job"-tickets that are Server-ready to deliver results for

Client exposes another REQ-socket to request upon an already broadcast "job"-ticket completion announcement message, it has just heard about over the SUB-socket, to get "job"-ticket results finally delivered, if proving itself, by providing a proper / matching job-ticket-AUTH-key to proof its right to receive the publicly announced results' availability, using this same socket to deliver a POSACK-message to Server upon client has correctly received this "job"-ticket results "in hands"

Server exposes REP-socket to respond each client ad-hoc upon a "job"-ticket request, notifying this way about having "accepted"-job-ticket, delivering also a job-ticket-AUTH-key for later pickup of results

Server exposes PUB-socket to announce any and all not yet picked-up "finished"-job-tickets

Server exposes another REP-socket to receive any possible attempt to request to deliver "job"-ticket-results. Upon verifying there delivered job-ticket-AUTH-key, Server decides whether the respective REQ-message had matching job-ticket-AUTH-key to indeed deliver a proper message with results, or whether a match did not happen, in which case a message will carry some other payload data ( logic is left for further thoughts, so as to prevent potential bruteforcing or eavesdropping and similar, less primitive attacks on stealing the results )

Clients need not stay waiting for results live/online and/or can survive certain amounts of LoS, L2/L3-errors or network-storm stresses

Clients need just to keep some kind of job-ticket-ID and job-ticket-AUTH-key for later retrieving of the Server-processes/maintained/auth-ed results

Server will keep listening for new jobs

Server will accept new job-tickets with providing a privately added job-ticket-AUTH-key

Server will process job-tickets as it will to do so

Server will maintain a circular-buffer of completed job-tickets to be announced

Server will announce, in due time and repeated as decided in public, job-tickets, that are ready for client-initiated retrieval

Server will accept new retrieval requests

Server will verify client-requests for matching any announced job-ticket-ID and testing if job-ticket-AUTH-key match either

Server will respond to either matching / non-matching job-ticket-ID results retrieval request(s)

Server will remove a job-ticket-ID from a circular-buffer only upon both POSACK-ed AUTH-match before a retrieval and a POSACK-message re-confirmed delivery to client

Per this github issue, you may have a conflict between dependencies of packages anaconda installed and the one you installed manually. Check your pythonpath and see if removing the pip folder from the pythonpath fixes the issue.