-
Configure CMake to generate libredox.so and libredox_static.a, and have all examples use the dynamic library. This is how Redox should be used in practice, and greatly reduces the compilation time of the examples. Also renamed redox.[ch]pp to client.[ch]pp and created one master header redox.hpp for users to include. This header right now just includes client.hpp, command.hpp, and subscriber.hpp.
-
Make .free() on commands send a message over an async watcher to the event loop, just like adding commands. This gets rid of some very tough to find memory bugs. Combined .cancel() with .free(), so there is only one method to call, whether for synchronous commands or for looped commands. Also debug some horrible segfaults related to Subscriber. Something is odd with hiredis and subscriptions, need to ask them. It seems when we flood with commands it doesn't disconnect cleanly. Look for a way to wait until all commands are processed.
-
Conform (mostly) to Google C++ guidelines. Apache license notice and link above each core file.
-
Refactor state management code to use three methods .connect(), .disconnect(), and .wait(). Start conforming to uniform coding style already applied to Command class. Split off subscribe functionality into its own class Subscriber. This is good because it was introducing unnecessary state and complexity into the main client. Now, Redox handles publishing like any other command and the Subscriber receives messages.
-
Using free_guard_ as the same mutex in .reply() causes deadlock when a callback accesses .reply(). Make a separate mutex.
-
Also make cmd.reply() copy the value and use a mutex to make it thread safe. No noticable speed hits, probably thanks to RVO.
-
Split up command into command, command_blocking, and command_looping. The original command no longer returns anything, which clarifies how it should be used in most cases. command_looping and command_blocking both return a command object. Also added a waiting CV to the Command object, though it is not used in command_blocking yet.
-
Now, there is only one callback for command(), and it returns a const reference to the Command object. The user is responsible for error checking using c.ok(), c.status(), and getting the reply with c.reply(). This significantly cleans up the library code and the user code. Greatly refactored the data type specialization code in command.cpp.
-
* Member variables with trailing underscore * Methods camelCase * Explicit template instantiation, move definitions to .cpp * Reorder methods to make more sense * Limit public API, comment well
-
subscribe/psubscribe/unsubscribe/punsubscribe methods that keep track of subscribed topics to make sure we don't ask hiredis for bad things. It appears all crashes are eliminated, though no stress testing has been done.
-
subscribe/unsubscribe/publish with proper and working callbacks. Guard added that throws an exception if a non-pubsub command is issued after a subscribe. Also removed all std:: prefixes from redox.cpp. Just made the decision for "using namespace std" there for readability. Not a header, of course. Also added another async watcher for breaking the loop, since ev_break doesn't actually do anything when called outside of an ev_run callback.
-
utils/logger.[ch]pp gives a logger implementation based on ostringstream that is pretty nice. I took this from Stack Overflow and added some things to make syntax nicer. Changed all cout and cerr statements in Redox to be of the form logger.{debug/info/warning/error/fatal}() << stuff. Arguments for non-printed statements are still evaluated. Gives a performance hit if we actually add statements on every callback and run speed tests. For most use cases, doesn't matter. For now, not including such low level output anyway. Would be nice to have a macro to leave out/include the low-level logs at compile-time. -
Implemented limited but useful binary data support without breaking the API. If the last character of the command is a ", look for the first ", and everything in between the quotes treat as binary data. Takes care of setting a key with a binary value. Not useful if there need to be multiple binary entries in one command, or for binary keys. Also need to be careful if the last character of the value actually needs to be a quote, in which case we need to quote the value.
-
Useful based on what kind of data you need.
-
Consolidated user callbacks into one, improved some logic.
-
Created an atomic_int connect_state that keeps track of not yet connected, connected, disconnected, and errors. Used to implement good error behavior when the server is down and you start() a Redox instance, or when the server goes down in the middle of running commands. Now, nothing should hang, but should return errors (or throw exceptions) when the server goes down. Also added hooks for a user connect/disconnect callback in the constructor, which is helpful for client programs. Added an example with three Redox clients in one thread.
-
Finally getting rid of the busy loop in the event thread. Now, we use an ev_async watcher that processes commands in the queue, which we can signal in a thread-safe manner using ev_async_send.
-
Instead of busy looping event thread, use a condition variable that is notified every time a command is sent or received, or every 100 milliseconds anyway.
-
submit_command_callback
-
Also plan to add in set<string> and unordered_set<string>. Maybe queue<string>. Looking at likely removing char* as an option, if it shows to be about the same speed as string.
-
Thoroughly cleaned up redox.hpp to expose a minimal public API, and commented those well. Generally cleaned up a bunch of stuff. Added wrapper function DEL, which could be useful.
-
Easy few lines for get and set commands that are easy to use. Implemented a condition variable that blocks run() until the event loop is running and Redis is connected. Also added a check to command() that will throw an exception if you try to add a command before calling run().
-
Fixed a couple of bugs found with a test case of 100 parallel asynchronous clients. As of now, there are no known memory leaks, segfaults, or deadlocks in Redox.
-
Ran into a nasty segfault when using 100 parallel asynchronous command loops, where a command's address would match up with a previous command's address. To circumvent the whole issue, Redox keeps a counter of how many Commands it has created and assigns each Command a unique id in the order they are created. Changed all data structures and methods to pass around Command IDs, so nothing uses void* anymore. I consider this a very good thing, but it did seem to slow down performance 20-30% because of the extra lookups. Will see if there's a solution later.
-
Take that, hours of debugging memory leaks! Did lots of structural tweaks to more smartly keep track of commands and make sure everything is evenutally freed from the heap.
-
Created a pointer Command.rdx (Redox*) to allow commands to increment Redox.cmd_count, and simplify a couple of other things. Did a little bit of moving and renaming context objects, so the context is always .ctx and commands can always be called c.
-
Added Command<nullptr_t> which successfully returns NIL replies from Redis, with REDOX_OK. Also renamed constants from REDISX_ -> REDOX_. Moved a bunch of code from redox.cpp into command.cpp, where it logically makes more sense.
-
Move as much as possible into the .cpp file, and clean things up.
-
Found out that ev_timer watchers have a void* data that allows currying information to the libev callbacks! That means I could stick the Command* in there and completely get rid of the global timer_callbacks map that was needed before. Additionally, we can move ev_timer into the Command object instead of separately allocating it on the heap. Simplifies management. Implemented a synchronous loop speed test based on the latest and greatest command_blocking(). Happy to see it is around 30k/s, which is 100% network delays.
-
Several hours of multithreaded debugging to find a nasty extra ampersand. command_blocking() now returns a Command object with the value and status accessible through methods. Added the option to free memory or not for Command objects when command() is called. If free_memory = true, then the Command object is freed after the callback or error callback returns. If free_memory = false, then the user must call cmd->free(). To implement this, we have to pass in a blank function to the freeObject entry in the hiredis redisReader, because otherwise it automatically frees memory. This was not cool for the blocking case.
-
Implemented error callbacks for command(). Now, either the success or error callbacks are guaranteed to return for any command. Added constants for error types. Many improvements and fixes for memory management. Command objects keep track of pending replies and delete themselves when completed. Changed ReplyT value to remove the const and reference requirements. Now, you do command<ReplyT> and the callback should take a const ReplyT&, whatever the type is. Makes things more uniform.
-
Renamed CommandAsync to Command to make things simpler, and refactored into its own file. command() now returns a pointer to the created Command object, which the client can pass into cancel() to stop any delayed or repeating calls. This is very important for an asynchronous client.
-
Uses libev timer watchers to queue commands on a regular interval. Very fast. Still need to handle deactivation of timers from the user side.
-
num_commands_processed(), trarcks using cmd_count and guarded with queue_guard.
-
Used to block the main thread until the event loop is stopped by calling the .stop() method. Implemented using a condition_variable, and very useful for clients.
-
Improved examples, added a threaded getter/setter example and cleaned up the other. Generally refactored code in the core files and cleaned up the details to make the slickest possible API. Implemented a to_exit variable as a stop condition for the event thread.