Rabbit | lightweight service that will build and store your go | Continous Integration library

According to the Spring Data JPA issue #2472 this seems to be a problem in Hibernate 5.6.6 and 5.6.7.

The Hibernate bug is HHH-15142.

The solution is to either downgrade to Hibernate 5.6.5 or wait for a Hibernate patch to solve this issue.

One approach is to define a helper function that matches for a specific animal, then bind the columns to the original frame.

Note that some wrangling is done to get rid of whitespace to identify the unique animals to query.

If the zero-parameter getInstance() is returning null, you have no singleton.

You have two processes. The StepCounterService is in the :stepCounterService process. StepCountUpdaterAlarm is in the default process. These processes share no objects, and so they will have separate StepCounterHandler singleton instances. If you have not done something previously to set up the StepCounterHandler in the default process, it will be null.

If you are expecting to share the singleton between StepCounterService and StepCountUpdaterAlarm, they will need to be in the same process. Either move StepCountUpdaterAlarm into the :stepCounterService process or move StepCounterService into the default process.

You can do this with a one-liner:

You are trying to group from a column that you aren't querying.

Try including this fields on the query

Hi all I'm going to answer my own question here might be useful to others. The answer for me is that it was because I was using a generic OpenBLAS, not an Intel processor-specific version of BLAS, and running in debug mode.

With optimization at compile time and using an Intel processor-specific version of BLAS:

1. Bt = B.t() and then A = Bt * C is definitely slower than A = B.t() * C, as we would expect due to the storing of the intermediate step.
2. A = B.t() * C is faster than A = B * C, if B is square (I know this isn't the same number), but the difference is small, maybe 0-20% for the numbers I am using.
3. Along a similar line, A = B.rows(0, 499) * C is slower than A = B.cols(0, 499).t() * C.

The explanation is I believe that column access is faster than row access. B.t() * C uses columns of both B and C, whereas B * C uses rows of B and columns of C.

All of this is much faster than loops. So use BLAS over C++ manual loops -- this is way more important than worrying about rows vs columns.

One anomaly: A = B.rows(0, 499) is still faster than A = B.cols(0, 499). Any ideas on why would be appreciated!

P.S. also tips on handing tensors higher than 2D in C++ would be appreciated. I hate arma::Cubes although I do use them.

You could do:

You can define on custom retry strategy on implementing the interface IExecutionStrategy. If you want reuse the default SQL Server retry strategy, you can derive from SqlServerRetryingExecutionStrategy on override the method ShouldRetryOn :

Even though your configured persistent messages on the payments queue, this just means messages will survive a broker restart - once a message has been consumed and acknowledged it would be removed.

If you know you're going to need the payment_analyze queue at some point in the future, is it viable to just create this queue/binding upfront and route messages to both payment_analyze and payments? Messages on the payment_analyze will bank up until you're ready to start consuming them. Note: If you're producing a large number of messages this approach might result in storage issues...

As an alternative, you could write the messages to BLOB storage (or some other data store) as part of your payments queue consumer (or a different queue/consumer altogether) and then when you're ready to introduce the payment_analyze queue, you could write a script to read all the old messages from BLOB storage and send them to the RabbitMQ exchange. With 'topic' exchanges - see here - you can probably be clever with wildcards and routing keys in your queue bindings to ensure both old messages (from BLOB storage) as well as new messages are both routed to the payment_analyze queue, but only new messages are routed to the payments queue (so that your payments queue consumer is not reprocessing old messages).

Another option (assuming you're not overly invested in RabbitMQ) could be to consider Apache Kafka instead which deals with this scenario quite nicely as messages aren't automatically removed from a partition once they've been processed by a subscriber.

Anyways, just a few options to consider...