RedisGears and C++ Client

Naeem_Saleem · July 12, 2020, 1:26pm

Hi Team,

I am currently working on a project that requires the automation of data ingestion into a database, application of pre-processing techniques (ICA, Singular Spectrum Analysis) and post processing through AI. Speed is a major factor in choosing the tech stack for this project as it’s a crucial factor in determining the success or failure of the project. Examples of redis edge have been very appealing. Currently, all my work is in C++ and I can successfully ingest data into RedisTimeSeries and Redis Streams.

Redis Gears (RG) would form an essential part of the stack (event driven data processing is essential for the project) but I am currently having difficulty working with Redis Gears as most of the examples are given with python. To justify using python I must demonstrate that it will outperform something similar produced in C++.

Is there a resource available for generic RG commands that are independent of Python?
Where do I start with the C API as I may investigate C/C++ wrappers?
What work arounds would you recommend generally?

I may consider developing an event driven system in C++ independent of redis gears but I believe in the law of economy so this would be the very last resort.

Any help in the right direction would be much appreciated.

Regards,
Naeem

meirsh · July 12, 2020, 2:34pm

Hey @Naeem_Saleem,

RedisGears C API is not yet documented because it’s not yet fully finalize (though it’s really mature and I believe that it will be finalized and documented in the near coming versions). That said, it does not mean you can not use it, its just mean that you should keep in mind that there might be small changes in the API that will require changes in your code.

The main benefit you will gain in using RedisGears and not Redis directly is:

Cluster support. So for example, if you use cluster or you choose to move to cluster one day, the fact that you are using Gears will make it very simple and almost smooth (maybe even entirely smooth if you follow some basic rules)
A more reach notification API, you can specify keys prefix, whether or not to read values. On streams, you can specify whether or not to trim the stream, what do to on failures, and so on … All this logic is already implemented in Gears and you get it for free by the fact that you are using RedisGears.

Please notice that if most of the computing time is spent on running AI models then I believe the python will not be a big overhead, That said if you choose to try the RedisGears and RedisIA C API I will be very happy to guide you closely through the development process. I will also understand if you decide not to do it because the API is not yet finalized.

If you choose to give it a try then continue reading, if not then you can stop reading now

So to get started I suggest you to take a look at this branch: Changes to gears core to support plugable plugings by MeirShpilraien · Pull Request #372 · RedisGears/RedisGears · GitHub
This branch (which will be merged to master once the review is finished) introduces the most recent changes to the API, but more importantly, it introduces Gears capability to load plugins (.so files), written in C or C++ (even RUST). Gears plugin can use all the Redis module C API but also the RedisGears C API. The RedisGears C API is given here: https://github.com/RedisGears/RedisGears/blob/gears_plugins_support_core_changes/src/redisgears.h
As I said it’s not yet documented but I believe that with some examples you can start work with it. The idea is that you need to put your compiled plugin in some directory and point RedisGears to look for plugins in this directory using PluginsDirectory configuration value (Read here on how to set RedisGears configuration value https://oss.redislabs.com/redisgears/configuration.html)

RedisGears will load your compiled .so file and call RedisGears_OnLoad function. This function must register your plugin using RedisGears_InitAsGearPlugin that gets RedisModuleCtx, plugin name, and plugin version. If this call success then your plugin was registered and you can continue.
See here for how we do it on the JVM plugin: https://github.com/RedisGears/RedisGears/blob/0d5aa2542c606b97b4e2bb9c303d1dd0408b4af9/plugins/gears_jvm/gears_jvm.c#L2898

After your plugin is registered you need to register callbacks functions. Those functions, after registered, will be accessible to be used on executions on the entire Redis cluster.
Again see the jvm example: https://github.com/RedisGears/RedisGears/blob/0d5aa2542c606b97b4e2bb9c303d1dd0408b4af9/plugins/gears_jvm/gears_jvm.c#L2951

Then you can build an execution plan and run it or register it on keyspace notification. This can be done like this:

char* err = NULL;
FlatExecutionPlan* rsctx = RGM_CreateCtx(KeysReader, &err);
RGM_Filter(rsctx, Example_Filter, NULL);
ExecutionPlan* ep = RGM_Run(rsctx, ExecutionModeAsync, readeArgs, NULL, NULL, NULL);

Again you can see how it was done on the jvm: https://github.com/RedisGears/RedisGears/blob/0d5aa2542c606b97b4e2bb9c303d1dd0408b4af9/plugins/gears_jvm/gears_jvm.c#L1184 https://github.com/RedisGears/RedisGears/blob/0d5aa2542c606b97b4e2bb9c303d1dd0408b4af9/plugins/gears_jvm/gears_jvm.c#L1694 https://github.com/RedisGears/RedisGears/blob/0d5aa2542c606b97b4e2bb9c303d1dd0408b4af9/plugins/gears_jvm/gears_jvm.c#L1926

You can also see how to use different readers: https://github.com/RedisGears/RedisGears/blob/0d5aa2542c606b97b4e2bb9c303d1dd0408b4af9/plugins/gears_jvm/gears_jvm.c#L1657 https://github.com/RedisGears/RedisGears/blob/0d5aa2542c606b97b4e2bb9c303d1dd0408b4af9/plugins/gears_jvm/gears_jvm.c#L1588

Now if your goal is to also integrate with RedisAI then take a look at RedisAI low-level API: https://github.com/RedisAI/RedisAI/blob/master/src/redisai.h

Naeem_Saleem · July 12, 2020, 8:59pm

Hello meirsh,

I am currently investigating the resources you have provided. Thank you for your guidance.

Regards,
Naeem

Naeem_Saleem · July 18, 2020, 6:57pm

meirsh,

I’ve run into an issue related to redisgears.h file whilst compiling a gears plugin:

github.com

RedisGears/RedisGears/blob/1aaffe7b013442d9b79704c2e940d245deaf1290/src/redisgears.h#L727


#endif
    return REDISMODULE_OK;
}

static int RedisGears_Initialize(RedisModuleCtx* ctx, const char* name, int version, bool initRedisModuleAPI){
    if(initRedisModuleAPI){
        if(RedisGears_InitializeRedisModuleApi(ctx) != REDISMODULE_OK){
            return REDISMODULE_ERR;
        }
    }
    if(!RedisModule_GetSharedAPI){
        RedisModule_Log(ctx, "warning", "redis version is not compatible with module shared api, use redis 5.0.4 or above.");
        return REDISMODULE_ERR;
    }

    REDISGEARS_MODULE_INIT_FUNCTION(ctx, GetLLApiVersion);

    REDISGEARS_MODULE_INIT_FUNCTION(ctx, CreateType);
    REDISGEARS_MODULE_INIT_FUNCTION(ctx, BufferCreate);
    REDISGEARS_MODULE_INIT_FUNCTION(ctx, BufferFree);
    REDISGEARS_MODULE_INIT_FUNCTION(ctx, BufferClear);

! RedisModule_GetSharedAPI is throwing an undefined identifier error. I can see it’s declared here:

github.com

RedisGears/RedisGears/blob/1aaffe7b013442d9b79704c2e940d245deaf1290/src/redisgears.h#L472


void MODULE_API_FUNC(RedisGears_LockHanlderRelease)(RedisModuleCtx* ctx);
int MODULE_API_FUNC(RedisGears_ExecuteCommand)(RedisModuleCtx *ctx, const char* logLevel, const char* __fmt, ...);

int MODULE_API_FUNC(RedisGears_RegisterPlugin)(const char* name, int version);

const char* MODULE_API_FUNC(RedisGears_GetConfig)(const char* name);

const int MODULE_API_FUNC(RedisGears_ExecutionPlanIsLocal)(ExecutionPlan* ep);

#define REDISGEARS_MODULE_INIT_FUNCTION(ctx, name) \
        RedisGears_ ## name = RedisModule_GetSharedAPI(ctx, "RedisGears_" #name);\
        if(!RedisGears_ ## name){\
            RedisModule_Log(ctx, "warning", "could not initialize RedisGears_" #name "\r\n");\
            return REDISMODULE_ERR; \
        }

#define REDISMODULE_MODULE_INIT_FUNCTION(ctx, name) \
        if(RedisModule_GetApi("RedisModule_" #name, &RedisModule_ ## name) != REDISMODULE_OK){ \
            RedisModule_Log(ctx, "warning", "could not initialize RedisModule_" #name "\r\n");\
            return REDISMODULE_ERR; \
        }

and here:

github.com

RedisGears/RedisGears/blob/1aaffe7b013442d9b79704c2e940d245deaf1290/src/redismodule.h#L680


RedisModuleTimerID REDISMODULE_API_FUNC(RedisModule_CreateTimer)(RedisModuleCtx *ctx, mstime_t period, RedisModuleTimerProc callback, void *data);
int REDISMODULE_API_FUNC(RedisModule_StopTimer)(RedisModuleCtx *ctx, RedisModuleTimerID id, void **data);
int REDISMODULE_API_FUNC(RedisModule_GetTimerInfo)(RedisModuleCtx *ctx, RedisModuleTimerID id, uint64_t *remaining, void **data);
const char *REDISMODULE_API_FUNC(RedisModule_GetMyClusterID)(void);
size_t REDISMODULE_API_FUNC(RedisModule_GetClusterSize)(void);
void REDISMODULE_API_FUNC(RedisModule_GetRandomBytes)(unsigned char *dst, size_t len);
void REDISMODULE_API_FUNC(RedisModule_GetRandomHexChars)(char *dst, size_t len);
void REDISMODULE_API_FUNC(RedisModule_SetDisconnectCallback)(RedisModuleBlockedClient *bc, RedisModuleDisconnectFunc callback);
void REDISMODULE_API_FUNC(RedisModule_SetClusterFlags)(RedisModuleCtx *ctx, uint64_t flags);
int REDISMODULE_API_FUNC(RedisModule_ExportSharedAPI)(RedisModuleCtx *ctx, const char *apiname, void *func);
void *REDISMODULE_API_FUNC(RedisModule_GetSharedAPI)(RedisModuleCtx *ctx, const char *apiname);
RedisModuleCommandFilter *REDISMODULE_API_FUNC(RedisModule_RegisterCommandFilter)(RedisModuleCtx *ctx, RedisModuleCommandFilterFunc cb, int flags);
int REDISMODULE_API_FUNC(RedisModule_UnregisterCommandFilter)(RedisModuleCtx *ctx, RedisModuleCommandFilter *filter);
int REDISMODULE_API_FUNC(RedisModule_CommandFilterArgsCount)(RedisModuleCommandFilterCtx *fctx);
const RedisModuleString *REDISMODULE_API_FUNC(RedisModule_CommandFilterArgGet)(RedisModuleCommandFilterCtx *fctx, int pos);
int REDISMODULE_API_FUNC(RedisModule_CommandFilterArgInsert)(RedisModuleCommandFilterCtx *fctx, int pos, RedisModuleString *arg);
int REDISMODULE_API_FUNC(RedisModule_CommandFilterArgReplace)(RedisModuleCommandFilterCtx *fctx, int pos, RedisModuleString *arg);
int REDISMODULE_API_FUNC(RedisModule_CommandFilterArgDelete)(RedisModuleCommandFilterCtx *fctx, int pos);
int REDISMODULE_API_FUNC(RedisModule_Fork)(RedisModuleForkDoneHandler cb, void *user_data);
int REDISMODULE_API_FUNC(RedisModule_ExitFromChild)(int retcode);
int REDISMODULE_API_FUNC(RedisModule_KillForkChild)(int child_pid);

What do you suggest for this error? Not sure whether it’s a scoping issue?

Given the limited documentation I have been hesitant to mess with the gears header file, so I decided to test my new dev environment by building a tiny custom module using your resources as a template (I’ve transferred my dev environment from windows to 100% linux, now using vscode)

I’ve successfully compiled, loaded and registered a custom module with redis installed on a single machine. Furthermore, Redis TimeSeries and Redis Streams are both working fine.

Obviously, I would like to move ahead and develop a redisgears plugin as you have already suggested.

Regards,
Naeem

meirsh · July 18, 2020, 7:30pm

Hey @Naeem_Saleem what are the chances you can upload your code (or part of it) to github so I can see exactly what is the issue?

Naeem_Saleem · July 18, 2020, 8:20pm

I’ve created a mini repo on git for you:

https://github.com/NMS0/RedisGears-Plugin.git

meirsh · July 18, 2020, 8:38pm

Getting 404 reply. Maybe its permissions issue?

Naeem_Saleem · July 18, 2020, 9:08pm

Sorry, please try again.

meirsh · July 19, 2020, 8:10am

Hey @Naeem_Saleem,

I made a small PR to your example repository. The problem was that the RedisModule_GetSharedAPI is defined as experimental feature and so need to be compiled with -DREDISMODULE_EXPERIMENTAL_API.

I also change the artifact name to redisg.so and I run RedisGears with those parameters:
redis-server --loadmodule ./redisgears.so PluginsDirectory /path/to/RedisGears-Plugin

Your plugin was loaded successfully:

23914:M 19 Jul 2020 10:54:26.891 * Loading plugin from file /home/meir/work/RedisGears-Plugin/redisg.so
23914:M 19 Jul 2020 10:54:26.891 # Loading plugin mygplugin version 1

Please make sure to use the gears_plugins branch until it will be merged to master.

Also notice that you do not need all the RedisGears .h files, you only need the redisgears.h, redismodule.h, util/arr_rm_alloc.h and util/arr.h (I also modified the util/arr_rm_alloc.h to allow it to compiled without redisgears_memory.h)

Let me know if anything else is needed.

Naeem_Saleem · July 19, 2020, 4:30pm

Dear meirsh,

I’ve implemented the changes you proposed and uploaded the compiled redisg.so file on git. This is the only reference to the plugin I get from the server:

23316:M 19 Jul 2020 20:13:14.083 * PluginsDirectory:./redisg.so

I get no confirmation that it’s loaded.

I normally load modules through config directives, the load modules section of the redis.conf file currently looks like this:

loadmodule ./redisai.so
loadmodule ./redisgears.so PluginsDirectory ./redisg.so
loadmodule ./redistimeseries.so

I tried the following commands too:

redis-server --loadmodule ./redisgears.so PluginsDirectory ./redisg.so

I get the same server response as above?

meirsh · July 19, 2020, 4:34pm

@Naeem_Saleem the PluginsDirectory config value get a directory and looks for .so files in this directory (I might allow specify a specific .so file also but currently on this branch it’s not supported). So you need to give the directory in which the redisg.so file is located and RedisGears will find it there and load it.

Naeem_Saleem · July 21, 2020, 7:49pm

@meirsh

Yes tried the directory only approach too. I’m getting the same server response after pointing rg to the plugin directory, this is the only reference to the plugin:

39656:M 21 Jul 2020 23:03:32.939 * PluginsDirectory:./Documents/RedisGears-Plugin

All modules are loading successfully just not getting confirmation from the server that the rg plugin has loaded but I’m not getting an error either. I am using redis 6.0.6.

meirsh · July 22, 2020, 5:41am

Strange, it works for me.
Can you share the full log file?

Naeem_Saleem · July 25, 2020, 11:00am

For the benefit of forum members the problem is solved by switching from Master branch to gears_plugins branch.

Thanks for all your help Meir.

Topic		Replies	Views
RedisGears looks interesting Redis modules	5	637	September 15, 2020
Cool New Module RedisGears	2	860	September 7, 2020
Which languages will be supported for Gears? RedisGears	11	1723	June 10, 2020
RediGears for other programming languages RedisGears	1	1149	June 6, 2020
Use cases RedisGears	1	643	March 30, 2020

RedisGears and C++ Client

Related topics