sebastien / k7 Goto Github PK

This would be good for libnode support

Right now, I don't think they work properly, but they are really important.

http://www.tildeslash.com/libzdb/download.html

as right now the documentation is a bit poor...

Right now, when a script fails we don't have a lot of useful information. For instance, running Narwhal leads to this:

./bin/narwhal
native runtime.js:160: TypeError: boolean is not a function
throw %MakeTypeError('called_non_callable', [typeof callee]);
^

While we'd like to have full traceback. This is very likely doable using K7, and quite important as otherwise debugging is hard. Maybe have a look at the D8 scripts shipped with V8.

Only initialize modules when they are actually referenced... if that's possible. This would allow to load K7 as fast as possible.

K7 doesn't have any db bindings, so starting with tokyocabinet would be good.

Libevent 1 is the default on most systems. If libevent 2 is better, then we should ship it with K7 and embed it in the deps so that it gets compiled as a dependency and then statically linked.

I'd personnaly prefer that the event module uses libevent1 by default and then has an option to use libevent2.

It would help reduce K7 binary size and allow to spread loading time over a larger period

For now, when throwing an exception from C/C++ code when libtask is enabled makes k7 core dump

Liboii would probably allow high-performance computation, especially useful for stats

It's small and probably better than what we use so far

http://www.gnu.org/software/libmicrohttpd/

Old-style parameter macros look ugly when instantiated in big numbers, allow an unnecessary degree of freedom (parameter indexes).

#define ARG_obj(v,i)  v8::Local<v8::Object> v=args[i]->ToObject();

leads to
ARG_COUNT(4);
ARG_utf8(data,0);
ARG_int(size,1);
ARG_int(nmemb,2);
ARG_obj(fileObj,3);

ARGINT-style macros may add too much overhead.

Need a new syntax, e.g.
FUNCTION(some_function, P_int(a), P_str(b), P_obj(c)) {
// a will be an int, b will be a str and c will be an obj
} END
plus pluggable error processing code, e.g.
#define ARGS_INVALID return JS_undefined;

Maximum execution time
Maximum memory consumption

Script termination from the side has now been added to V8. Look for
the TerminateExecution methods in the API and have a look at the
test/cctest/test-thread-termination.cc test file for examples of using
it.

http://www.linuxnetworks.de/doc/index.php/OpenDBX

To me, having python & scons required to build k7 (and v8) is barrier to making k7 more portable. To remove, python & scons, the following is needed:

• A little bit of OS & CPU (uname) to pick the right platform files for v8
• Some makefile magic to do the libraries-empty.cc => libraries.cc compilation from the v8 JS library files
• js2h python script replaced by a C/C++ file and jsmin.c from http://www.crockford.com/javascript/jsmin.html

I have some notes on this and was working on this in a private tree.

Dyncall is like libFFI, only better and simpler
http://dyncall.org/

Extend offers OOP, utility function and python-like datatypes that could be really useful for better server-side programming.

With latest version of K7, I get a segfault when executing

./k7 tests/module-system- event.js
bound!

event added fd 5
yep,added

expected err: Error: Operation now in progress

connected

event added fd 6
Uncaught exception: Error: Invalid argument
Segmentation fault

With gdb output

[Switching to Thread 0xb796f6f0 (LWP 30101)]
0xb7ce6613 in strlen () from /lib/tls/i686/cmov/libc.so.6
(gdb) backtrace
#0 0xb7ce6613 in strlen () from /lib/tls/i686/cmov/libc.so.6
#1 0x08066264 in v8::String::New ()
#2 0xbfd8d1ec in ?? ()
#3 0x08076441 in v8::internal::Builtin_HandleApiCall ()
#4 0x00000001 in ?? ()
Backtrace stopped: previous frame inner to this frame (corrupt stack?)

Here are some examples that should be ported to K7

http://lua-users.org/wiki/LuaCoroutinesVersusPythonGenerators

K7 should offer primitive for accessing and manipulating modules (in plain C++):

• find(moduleName): finds the .js or .so representing the module in one of the K7_PATH dirs
• load(modulePath): loads the .js or .so module at the given location
• reload(modulePath): reloads the .js or .so module at the given location

Right now startup times are about 80ms on my machine, while Python starts in 40ms and spidermonkey in 4ms...

I'd like to be able to write glue code in a manner similar to this.

OBJECT( posix_FILE, 1, FILE* file )

{

OBJECT_SCOPE_START();

OBJECT_INTERNAL_SETUP( 1 );

INTERNAL( 0, file );

return( self );

};

FUNCTION( posix_fputs )

{

SCOPE_START();

ARG_utf8( str, 0 );

ARG_obj( fObj, 1 );

EXTERNAL( FILE*, file, fObj, 0 );

return( JS_int( fputs( *str, file ) ) );

}