live: use mostly pure V code for reloading, eases customization

pull/4693/head
Delyan Angelov 2020-05-03 18:59:11 +03:00
parent b4e4e6bb21
commit 845ffb59a6
13 changed files with 282 additions and 210 deletions

View File

@ -0,0 +1,5 @@
module main
// This prelude is loaded in every v program compiled with -live,
// in both the main executable, and in the shared library.
import live

View File

@ -1,11 +1,5 @@
module main
import os
import time
import dl
const (
os_used = os.MAX_PATH
time_used = time.now()
dl_used = dl.version
)
// This prelude is loaded in every v program compiled with -live,
// but only for the main executable.
import live.executable

View File

@ -1,9 +1,5 @@
module main
import os
import time
const (
os_used = os.MAX_PATH
time_used = time.now()
)
// This prelude is loaded in every v program compiled with -live,
// but only for the shared library.
import live.shared

View File

@ -79,8 +79,8 @@ const (
[live]
fn (game &Game) draw() {
game.gg.draw_rect(game.x, game.y, width, width, blue)
game.gg.draw_rect(550 - game.x + 10, 200 - game.y + 50, width, width, gx.rgb(128, 10, 255))
game.gg.draw_rect(game.x - 20, 250 - game.y, width, width, gx.rgb(128, 240, 155))
game.gg.draw_rect(550 - game.x + 10, 200 - game.y + 50, width, width, gx.rgb(228, 10, 55))
game.gg.draw_rect(game.x - 25, 250 - game.y, width, width, gx.rgb(28, 240, 55))
}
[live]

View File

@ -1,13 +1,13 @@
module main
// Build this example with
// v -live message.v
// Build this example with `v -live message.v`
import time
import live
[live]
fn print_message() {
println('Hello! Modify this message while the program is running.')
info := live.info()
println('OK reloads: ${info.reloads_ok:4d} | Total reloads: ${info.reloads:4d} | Hello! Modify this message while the program is running.')
}
fn main() {

View File

@ -4,6 +4,7 @@ module dl
pub const (
RTLD_NOW = C.RTLD_NOW
RTLD_LAZY = C.RTLD_LAZY
DL_EXT = '.so'
)

View File

@ -2,6 +2,7 @@ module dl
pub const (
RTLD_NOW = 0
RTLD_LAZY = 0
DL_EXT = '.dll'
)

60
vlib/live/common.v 100644
View File

@ -0,0 +1,60 @@
module live
pub type FNLinkLiveSymbols = fn (linkcb voidptr)
pub type FNLiveReloadCB = fn (info &LiveReloadInfo)
pub struct LiveReloadInfo {
pub:
vexe string // full path to the v compiler
vopts string // v compiler options for a live shared library
original string // full path to the original source file, compiled with -live
live_fn_mutex voidptr // the address of the C mutex, that locks the [live] fns during reloads.
live_linkfn FNLinkLiveSymbols // generated C callback; receives a dlopen handle
so_extension string // .so or .dll
so_name_template string // a sprintf template for the shared libraries location
mut:
live_lib voidptr // the result of dl.open
reloads int // how many times a reloading was tried
reloads_ok int // how many times the reloads succeeded
reload_time_ms int // how much time the last reload took (compilation + loading)
last_mod_ts int // a timestamp for when the original was last changed
recheck_period_ms int = 100 // how often do you want to check for changes
cb_recheck FNLiveReloadCB = 0 // executed periodically
cb_compile_failed FNLiveReloadCB = 0 // executed when a reload compilation failed
cb_before FNLiveReloadCB = 0 // executed before a reload try happens
cb_after FNLiveReloadCB = 0 // executed after a reload try happened, even if failed
cb_locked_before FNLiveReloadCB = 0 // executed before lib reload, in the mutex section
cb_locked_after FNLiveReloadCB = 0 // executed after lib reload, in the mutex section
}
// LiveReloadInfo.live_linkfn should be called by the reloader
// to dlsym all live functions. TODO: research a way to implement
// live_linkfn in pure V, without complicating live code generation
// too much.
//
// The callbacks: cb_compile_fail, cb_before, cb_after will be
// executed outside the mutex protected section, so be careful,
// if you modify your data inside them. They can race with your
// [live] functions.
//
// cb_locked_before and cb_locked_after will be executed *inside*
// the mutex protected section. They can NOT race with your [live]
// functions. They should be very quick in what they do though,
// otherwise your live functions can be delayed.
//
// live.info - give user access to program's LiveReloadInfo struct,
// so that the user can set callbacks, read meta information, etc.
pub fn info() &LiveReloadInfo {
if C.g_live_info != 0 {
return C.g_live_info
}
// When the current program is not compiled with -live, simply
// return a new empty struct LiveReloadInfo in order to prevent
// crashes. In this case, the background reloader thread is not
// started, and the structure LiveReloadInfo will not get updated.
// All its fields will be 0, but still safe to access.
mut x := &LiveReloadInfo{}
C.g_live_info = voidptr(x)
return x
}

View File

@ -0,0 +1,164 @@
module executable
import os
import time
import dl
import strconv
import live
// The live reloader code is implemented here.
fn C.pthread_mutex_unlock(mtx voidptr)
fn C.pthread_mutex_lock(mtx voidptr)
// NB: new_live_reload_info will be called by generated C code inside main()
pub fn new_live_reload_info(original string, vexe string, vopts string, live_fn_mutex voidptr, live_linkfn live.FNLinkLiveSymbols) &live.LiveReloadInfo {
file_base := os.file_name(original).replace('.v', '')
so_dir := os.cache_dir()
so_extension := dl.DL_EXT
/* $if msvc { so_extension = '.dll' } $else { so_extension = '.so' } */
return &live.LiveReloadInfo{
original: original
vexe: vexe
vopts: vopts
live_fn_mutex: live_fn_mutex
live_linkfn: live_linkfn
so_extension: so_extension
so_name_template: '${so_dir}/tmp.%d.${file_base}'
live_lib: 0
reloads: 0
reload_time_ms: 0
}
}
// NB: start_reloader will be called by generated code inside main(), to start
// the hot code reloader thread. start_reloader is executed in the context of
// the original main thread.
pub fn start_reloader(r mut live.LiveReloadInfo) {
// The shared library should be loaded once in the main thread
// If that fails, the program would crash anyway, just provide
// an error message to the user and exit:
r.reloads++
_ := compile_and_reload_shared_lib(r) or {
eprintln( err )
exit(1)
}
go reloader(r)
}
[if debuglive]
fn elog(r mut live.LiveReloadInfo, s string){
eprintln(s)
}
fn compile_and_reload_shared_lib(r mut live.LiveReloadInfo) ?bool {
sw := time.new_stopwatch()
new_lib_path := compile_lib(r) or {
return error('errors while compiling $r.original')
}
elog(r,'> compile_and_reload_shared_lib compiled: ${new_lib_path}')
load_lib(r, new_lib_path )
r.reload_time_ms = sw.elapsed().milliseconds()
return true
}
fn compile_lib(r mut live.LiveReloadInfo) ?string {
new_lib_path, new_lib_path_with_extension := current_shared_library_path(r)
cmd := '$r.vexe $r.vopts -o $new_lib_path $r.original'
elog(r,'> compilation cmd: $cmd')
cwatch := time.new_stopwatch()
recompilation_result := os.exec( cmd ) or {
eprintln('recompilation failed')
return none
}
elog(r,'compilation took: ${cwatch.elapsed().milliseconds()}ms')
if recompilation_result.exit_code != 0 {
eprintln('recompilation error:')
eprintln( recompilation_result.output )
return none
}
if !os.exists( new_lib_path_with_extension ) {
eprintln('new_lib_path: $new_lib_path_with_extension does not exist')
return none
}
return new_lib_path_with_extension
}
fn current_shared_library_path(r mut live.LiveReloadInfo) (string, string) {
lib_path := strconv.v_sprintf(r.so_name_template.replace('\\', '\\\\'), r.reloads)
lib_path_with_extension := lib_path + r.so_extension
return lib_path, lib_path_with_extension
}
fn load_lib(r mut live.LiveReloadInfo, new_lib_path string) {
elog(r,'live mutex locking...')
C.pthread_mutex_lock(r.live_fn_mutex)
elog(r,'live mutex locked')
//
if r.cb_locked_before != 0 {
r.cb_locked_before( r )
}
//
protected_load_lib(r, new_lib_path)
//
r.reloads_ok++
if r.cb_locked_after != 0 {
r.cb_locked_after( r )
}
//
elog(r,'live mutex unlocking...')
C.pthread_mutex_unlock(r.live_fn_mutex)
elog(r,'live mutex unlocked')
}
fn protected_load_lib(r mut live.LiveReloadInfo, new_lib_path string) {
if r.live_lib != 0 {
dl.close( r.live_lib )
r.live_lib = 0
}
r.live_lib = dl.open(new_lib_path, dl.RTLD_LAZY)
if r.live_lib == 0 {
eprintln('opening $new_lib_path failed')
exit(1)
}
r.live_linkfn( r.live_lib )
elog(r,'> load_lib OK, new live_lib: $r.live_lib')
// removing the .so file from the filesystem after dlopen-ing
// it is safe, since it will still be mapped in memory
os.rm( new_lib_path )
}
// NB: r.reloader() is executed in a new, independent thread
fn reloader(r mut live.LiveReloadInfo) {
elog(r,'reloader, r: $r')
mut last_ts := os.file_last_mod_unix( r.original )
for {
if r.cb_recheck != 0 {
r.cb_recheck( r )
}
now_ts := os.file_last_mod_unix( r.original )
if last_ts != now_ts {
r.reloads++
last_ts = now_ts
r.last_mod_ts = last_ts
if r.cb_before != 0 {
r.cb_before( r )
}
compile_and_reload_shared_lib(r) or {
if r.cb_compile_failed != 0 {
r.cb_compile_failed( r )
}
if r.cb_after != 0 {
r.cb_after( r )
}
continue
}
if r.cb_after != 0 {
r.cb_after( r )
}
}
if r.recheck_period_ms > 0 {
time.sleep_ms(r.recheck_period_ms)
}
}
}

View File

@ -0,0 +1,3 @@
module shared
import live

View File

@ -151,6 +151,9 @@ pub fn (v Builder) get_user_files() []string {
// See cmd/tools/preludes/README.md for more info about what preludes are
vroot := os.dir(pref.vexe_path())
preludes_path := os.join_path(vroot, 'cmd', 'tools', 'preludes')
if v.pref.is_livemain || v.pref.is_liveshared {
user_files << os.join_path(preludes_path, 'live.v')
}
if v.pref.is_livemain {
user_files << os.join_path(preludes_path, 'live_main.v')
}

View File

@ -171,6 +171,8 @@ extern wchar_t **_wenviron;
#include <pthread.h>
#endif
// g_live_info is used by live.info()
void* g_live_info = NULL;
//============================== HELPER C MACROS =============================*/
//#define tos4(s, slen) ((string){.str=(s), .len=(slen)})

View File

@ -6,69 +6,38 @@ import v.pref
import v.util
fn (g &Gen) generate_hotcode_reloading_declarations() {
if g.pref.os != .windows {
if g.pref.is_livemain {
g.hotcode_definitions.writeln('pthread_mutex_t live_fn_mutex = PTHREAD_MUTEX_INITIALIZER;')
}
if g.pref.is_liveshared {
g.hotcode_definitions.writeln('pthread_mutex_t live_fn_mutex;')
}
} else {
if g.pref.os == .windows {
if g.pref.is_livemain {
g.hotcode_definitions.writeln('HANDLE live_fn_mutex = 0;')
}
if g.pref.is_liveshared {
g.hotcode_definitions.writeln('HANDLE live_fn_mutex;')
}
g.hotcode_definitions.writeln('
void pthread_mutex_lock(HANDLE *m) {
WaitForSingleObject(*m, INFINITE);
}
void pthread_mutex_unlock(HANDLE *m) {
ReleaseMutex(*m);
}')
}
')
} else {
if g.pref.is_livemain {
g.hotcode_definitions.writeln('pthread_mutex_t live_fn_mutex = PTHREAD_MUTEX_INITIALIZER;')
}
if g.pref.is_liveshared {
g.hotcode_definitions.writeln('pthread_mutex_t live_fn_mutex;')
}
}
}
fn (g &Gen) generate_hotcode_reloader_code() {
if g.pref.is_liveshared {
g.hotcode_definitions.writeln('')
g.hotcode_definitions.writeln('int load_so(byteptr path) { return 0; }')
g.hotcode_definitions.writeln('')
return
}
// Hot code reloading
if g.pref.is_livemain {
mut file := os.real_path(g.pref.path)
file_base := os.file_name(file).replace('.v', '')
// Need to build .so file before building the live application
// The live app needs to load this .so file on initialization.
mut vexe := pref.vexe_path()
mut so_dir := os.cache_dir()
if os.user_os() == 'windows' {
vexe = util.cescaped_path(vexe)
file = util.cescaped_path(file)
so_dir = util.cescaped_path(so_dir)
}
mut msvc := ''
if g.pref.ccompiler == 'msvc' {
msvc = '-cc msvc'
}
so_debug_flag := if g.pref.is_debug { '-cg' } else { '' }
cmd_compile_shared_library := '$vexe $msvc -cg -keepc $so_debug_flag -o ${so_dir}/${file_base} -sharedlive -shared $file'
if g.pref.is_verbose {
println(cmd_compile_shared_library)
}
ticks := time.ticks()
so_compilation_result := os.system(cmd_compile_shared_library)
if g.pref.is_verbose {
diff := time.ticks() - ticks
println('compiling shared library took $diff ms')
}
if so_compilation_result != 0 {
exit(1)
}
mut phd := ''
mut load_code := []string{}
if g.pref.os != .windows {
@ -83,181 +52,55 @@ fn (g &Gen) generate_hotcode_reloader_code() {
phd = windows_hotcode_definitions_1
}
g.hotcode_definitions.writeln(phd.replace('@LOAD_FNS@', load_code.join('\n')))
g.hotcode_definitions.writeln('
void lfnmutex_print(char *s){
#if 0
fflush(stderr);
fprintf(stderr,">> live_fn_mutex: %p | %s\\n", &live_fn_mutex, s);
fflush(stderr);
#endif
}
void remove_so_file(char *s){
// removing the .so file from the filesystem after dlopen-ing it is safe, since it will still be mapped in memory.
#ifndef _WIN32
unlink(s);
#else
_unlink(s);
#endif
}
int _live_reloads = 0;
void reload_so() {
char new_so_base[PATH_MAX] = {0};
char new_so_name[PATH_MAX] = {0};
char compile_cmd[PATH_MAX] = {0};
int last = os__file_last_mod_unix(tos2("$file"));
while (1) {
// TODO use inotify
int now = os__file_last_mod_unix(tos2("$file"));
if (now != last) {
last = now;
_live_reloads++;
//v -o bounce -sharedlive -shared bounce.v
snprintf(new_so_base, sizeof (new_so_base), "${so_dir}/tmp.%d.${file_base}", _live_reloads);
#ifdef _MSC_VER
snprintf(new_so_name, sizeof (new_so_name), "%s.dll", new_so_base);
#else
snprintf(new_so_name, sizeof (new_so_name), "%s.so", new_so_base);
#endif
snprintf(compile_cmd, sizeof (compile_cmd), "$vexe $msvc $so_debug_flag -cg -keepc -o %s -sharedlive -shared $file", new_so_base);
os__system(tos2(compile_cmd));
if( !os__exists(tos2(new_so_name)) ) {
puts("Errors while compiling $file\\n");
continue;
}
lfnmutex_print("reload_so locking...");
pthread_mutex_lock(&live_fn_mutex);
lfnmutex_print("reload_so locked");
load_so(new_so_name);
remove_so_file( new_so_name );
lfnmutex_print("reload_so unlocking...");
pthread_mutex_unlock(&live_fn_mutex);
lfnmutex_print("reload_so unlocked");
}
time__sleep_ms(100);
}
}
')
}
}
const (
posix_hotcode_definitions_1 = '
#include <limits.h>
#ifndef PATH_MAX
#define PATH_MAX 1024
#endif
void* live_lib = 0;
int load_so(byteptr path) {
char cpath[PATH_MAX] = {0};
int res = snprintf(cpath, sizeof(cpath), "%s", path);
if (res >= sizeof (cpath)) {
fprintf (stderr, "path is too long");
return 0;
}
if (live_lib) {
int closing_status = dlclose(live_lib);
//fprintf(stderr, "Closing status: %d\\n", closing_status);
live_lib = 0;
}
//fprintf (stderr, "Opening shared library at: %s\\n", cpath);
live_lib = dlopen(cpath, RTLD_LAZY);
if (!live_lib) {
fprintf(stderr, "open failed, reason: %s\\n", dlerror());
exit(1);
return 0;
}
dlerror(); // clear errors
//fprintf(stderr, "live_lib: %p\\n", live_lib);
void v_bind_live_symbols(void* live_lib){
@LOAD_FNS@
char *dlsym_error = dlerror();
if (dlsym_error != NULL) {
fprintf(stderr, "dlsym failed, reason: %s\\n", dlsym_error);
}
return 1;
}
'
windows_hotcode_definitions_1 = '
#ifndef PATH_MAX
#define PATH_MAX 1024
#endif
void pthread_mutex_lock(HANDLE *m) {
WaitForSingleObject(*m, INFINITE);
}
void pthread_mutex_unlock(HANDLE *m) {
ReleaseMutex(*m);
}
void* live_lib = NULL;
int load_so(byteptr path) {
char cpath[PATH_MAX];
int res = snprintf(cpath, sizeof(cpath), "%s", path);
if (res >= sizeof(cpath)) {
puts("path is too long\\n");
exit(1);
return 0;
}
if (live_lib) FreeLibrary(live_lib);
live_lib = LoadLibraryA(cpath);
if (!live_lib) {
puts("open failed\\n");
exit(1);
return 0;
}
void v_bind_live_symbols(void* live_lib){
@LOAD_FNS@
return 1;
}
'
)
//
fn (g &Gen) generate_hotcode_reloading_main_caller() {
if !g.pref.is_livemain {
return
}
g.writeln('')
// We are in live code reload mode, so start the .so loader in the background
file_base := os.file_name(g.pref.path).replace('.v', '')
mut so_dir := os.cache_dir()
if os.user_os() == 'windows' {
so_dir = util.cescaped_path(so_dir)
}
g.writeln('\t// live code initialization section:')
g.writeln('\t{')
g.writeln('\t\t// initialization of live function pointers')
for fname in g.hotcode_fn_names {
g.writeln('\t\timpl_live_${fname} = 0;')
}
vexe := util.cescaped_path( pref.vexe_path() )
file := util.cescaped_path( g.pref.path )
msvc := if g.pref.ccompiler == 'msvc' { '-cc msvc' } else { '' }
so_debug_flag := if g.pref.is_debug { '-cg' } else { '' }
vopts := '$msvc $so_debug_flag -keepc -sharedlive -shared'
//
g.writeln('\t\t// start background reloading thread')
if g.pref.os != .windows {
// unix:
so_name := file_base + '.so'
g.writeln('\t\tchar *live_library_name = "${so_dir}/$so_name";')
g.writeln('\t\tload_so(live_library_name);')
g.writeln('\t\tpthread_t _thread_so;')
g.writeln('\t\tpthread_create(&_thread_so , NULL, (void *)&reload_so, live_library_name);')
} else {
// windows:
so_extension := if g.pref.ccompiler == 'msvc' { '.dll' } else { '.so' }
so_name := file_base + so_extension
g.writeln('\t\tchar *live_library_name = "${so_dir}/$so_name";')
if g.pref.os == .windows {
g.writeln('\t\tlive_fn_mutex = CreateMutexA(0, 0, 0);')
g.writeln('\t\tload_so(live_library_name);')
g.writeln('\t\tunsigned long _thread_so;')
g.writeln('\t\t_thread_so = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)&reload_so, 0, 0, 0);')
}
g.writeln('\t\tlive__LiveReloadInfo* live_info = live__executable__new_live_reload_info(')
g.writeln('\t\t\t\t\t tos2("$file"),')
g.writeln('\t\t\t\t\t tos2("$vexe"),')
g.writeln('\t\t\t\t\t tos2("$vopts"),')
g.writeln('\t\t\t\t\t &live_fn_mutex,')
g.writeln('\t\t\t\t\t v_bind_live_symbols')
g.writeln('\t\t);')
// g_live_info gives access to the LiveReloadInfo methods,
// to the custom user code, through calling v_live_info()
g.writeln('\t\t g_live_info = (void*)live_info;')
g.writeln('\t\tlive__executable__start_reloader(live_info);')
g.writeln('\t}\t// end of live code initialization section')
g.writeln('')
}