At the moment, we just instrument and compile a single function/file at a time. Actually, as far as I know, most of the state-of-the-art tools do not go much further than this (see Austin and CAVM). Therefore, making it work in the context of a whole system could be hard. We could adapt our current instrumentation workflow to make OCELOT work also with functions that call other functions, but it would require building the entire project every time we change the function we want to test, and it may take hours for big projects. Anyway, I would like to propose a slightly different instrumentation workflow that would not require a full build of the project each time we change function.
For a project P:
[ ] Instrument all the project. With this step, we instrument all the functions. We add a parameter to the tracing functions, _function_id, and every function is instrumented so that it calls the tracing function with its own id. The tracking function is aware of the function that is calling it. We just need to filter all the calls from the function that we want to test, using its id, to generate test cases for it.
[ ] Modify the project Makefile. We need to make sure that the output of the build is a ".so" library, rather than an executable file. To do this, we have to check and, if necessary, modify the makefile of the project.
[ ] Build the whole project. This is straightforward, we just need to call "make".
For each function F to test:
[ ] Modify and build the JNI module. This step is necessary to (i) link the project ".so" file to the JNI module and (ii) to setup the module for the function
intersimone999
commented
7 years ago 
At the moment, we just instrument and compile a single function/file at a time. Actually, as far as I know, most of the state-of-the-art tools do not go much further than this (see Austin and CAVM). Therefore, making it work in the context of a whole system could be hard. We could adapt our current instrumentation workflow to make OCELOT work also with functions that call other functions, but it would require building the entire project every time we change the function we want to test, and it may take hours for big projects. Anyway, I would like to propose a slightly different instrumentation workflow that would not require a full build of the project each time we change function.
For a project P:
_function_id, and every function is instrumented so that it calls the tracing function with its own id. The tracking function is aware of the function that is calling it. We just need to filter all the calls from the function that we want to test, using its id, to generate test cases for it.For each function F to test:
tl;dr: OCELOT should work in three steps: