IRC channel logs

2018-08-26.log

back to list of logs

***Server sets mode: +nt
<Sheilong>I am trying to access the elements of a bytevector, but did't find anything at the documentation, I want to perform some operation under its elements
<mwette>Sheilong: check the guile ref man, Section 6.6.12, (or better yet, the the procedure index). for example, (bytevector-ieee-double-ref bv 1)
<Sheilong>I am on it, but haven't seem this procedure
<amz3>hello #guile
<mwette>hi!
<janneke>hi!
<wingo>jit seems to speed up map on a 1e7-element list by 1x (mapping 1+ takes 320-440ms instead of 610-730ms)
<mwette>wingo: cool -- Hey, have you every looked at the VEX in valgrind to see how CPUs are characterized there? VEX may be more aggressive about covering instruction sets.
<wingo>mwette: you mean as a jit library? no i never thought about that
<wingo>it's an interesting idea :)
<wingo>ime lightning is ok provided that what you want to do is part of its instruction set. however everything having to do with procedure calls is a bit weird
<mwette>Does V8 do more?
<wingo> https://archive.fosdem.org/2017/schedule/event/valgrind_vex_future/attachments/slides/1842/export/events/attachments/valgrind_vex_future/slides/1842/valgrind_vex_future.pdf is a recent presentation
<wingo>mwette: v8 etc all just have a c++ library embedded in them that's an assembler that directly supports the instructions they want to emit, for each architecture. sometimes they layer a macroassembler above it. for optimized compilation, the compiler IR eventually gets lowered to something corresponding to some abstract IR corresponding to assembly; instruction selection actally produces the assembly via calls to the assembler library
<wingo>basically the assembler is dumb and the compiler is smart
<wingo>lightning used to be dumb but it got smarter it seems (e.g. register allocation etc); dunno if that is good or not :)
<wingo>it used to be v8 and friends just duplicated a bunch of code for each architecutre
<wingo>you'd have jit-ia32.c, jit-x64.c, etc
<wingo>in that case, obviously there's no need for an assembly abstraction. but it was hard to maintain :P
<mwette>in valgrind the file to look at is VEX/pub/libvex_ir.h
<wingo>will have a look
<wingo>switching jit libraries won't be that bad if we end up doing it
<mwette>well valgrind is the opposite: it converts machine code to IR
<mwette>but there is the IR model none-the-less
<wingo>of course but it does the jit too
<mwette>didn't mnow that
<mwette>I know of JIT mach-code to IR. I created a tool w/ valgrind to count CPU cycles in a chosen segment of user code (https://github.com/mwette/cputil).
<mwette>brb
<wingo>lloda: have you been able to make more experiments?
*wingo afk for a while
<hugo>wingo: A Guile Notebook would be cool. Currently I'm kinda using emacs with geiser as one, but it's for from perfect.
<hugo>manumanumanu: Yeah, I'm studying CS. So hopefully I know at least some things.
<qtoni>Aye aye, I can get documentation of functions and symbols via ",d <var>" in the REPL, but how can I write this documentation for my own functions?
<sneek>Welcome back qtoni, you have 1 message.
<sneek>qtoni, amz3 says: here is talk you might be interested https://fosdem.org/2018/schedule/event/code_graph_based_analysis_of_javascript_repositories/
<mwette>test
<weinholt>you will not believe it, but the test failed
<mwette>damn
***rekado_ is now known as rekado
<hugo>qtoni: If the first expression of a function (directly after the parameter list) is a string then that is used as the documentation.