<Camarade_Tux>
unfortunately, they're not really searchable: there's one file per day and no seach function (the links at the top of the page are dead) =/
<thelema>
wget + grep
<Camarade_Tux>
well, yeah, it's a bit heavy though ;-)
<thelema>
there can't be more than a few megs of logs there
<Camarade_Tux>
yeah and I have a timeframe for that but still
<Camarade_Tux>
actually I think I have a pretty precise timeframe :)
<thelema>
right now?
ttamttam has quit ["Leaving."]
<Camarade_Tux>
a few days before halloween: 29/10/2009 :)
stoff_ has quit [Read error: 110 (Connection timed out)]
ttamttam has joined #ocaml
ttamttam has quit [Client Quit]
ikaros has joined #ocaml
ygrek has quit [Remote closed the connection]
ygrek has joined #ocaml
monipol has joined #ocaml
_zack has quit ["Leaving."]
<monipol>
Hello, folks. Any idea when 3.11.2 will be released?
<thelema>
monipol: when it's ready
<monipol>
I've just found out that the -output-obj bug I'm getting has been fixed in HEAD.
<monipol>
Heh, okay, thelema.
<thelema>
yay. Try building the SVN ocaml - it's not too hard.
<monipol>
Not my call I'm afraid.
Associat0r has joined #ocaml
middayc has joined #ocaml
ttamttam has joined #ocaml
<thelema>
then you're stuck. As far as I've been able to tell, there's no pattern on ocaml releases - they come out whenever xavier feels like it.
<monipol>
Is he xleroy?
<Camarade_Tux>
yes
<Camarade_Tux>
but I think 3.11.2 shouldn't be too long to appear, not on tomorrow though
<monipol>
Okay. I think I'll just disable Unison with native Mac UI for the moment.
<middayc>
so ocaml is "run" by one man like python, ruby.. and many others? I thought it'a project of some french university
<Camarade_Tux>
well, he's the lead
<Camarade_Tux>
and it's run by a government reseach agency
<Camarade_Tux>
*research
<thelema>
he's ocaml kahuna #1
<middayc>
aha :)
<middayc>
is there anything like roadmap for ocaml .. I really like it, but it gives a feeling like it's there as it is and there is not much plans to evolve it and push it further .. I can't see any future tense on it's page
<thelema>
I have to admit that the inria folks seem mostly in maintenance mode, except for the occasional surprise feature add (like ocamlbuild)
<thelema>
I think they're directed mostly by requests from the caml consortium members
<thelema>
although maybe xavier had something better to say at the last ocaml meeting
<Camarade_Tux>
hmmm, I see new features added and developped actually
<Camarade_Tux>
but I have to say the team isn't very communicative
<middayc>
thelema: yes, that is the feeling I get ... here seems the best nonscripting language I have seen, it has quite a lot of libs for practical work too but it seems below critical mass to have things mainatined and expanding..
<middayc>
and if language doesn't show exciting future it's also harder to excite people to start using it and heat up the whole ecosystem
<middayc>
(I wouldn't care if I didn't really like the language)
<thelema>
There's a ton of things that could be added to ocaml core. I believe that the most important of these to wide adoption is a better set of core libraries
<thelema>
language features like GADTs or fancier threading don't compel me towards a language
<middayc>
ok, the creationg of bateries included project and stuff from JaneStreet give very very nice signals
<middayc>
and oc4mc and hlvm .. but I don't know how soon there will usable stuff there
<thelema>
I'm very happy with janestreet's latest gift to the community through their summer of ocaml project - ocamlviz
<thelema>
hlvm... not yet.
* Camarade_Tux
still hasn't tried ocamlviz
<flux>
and the next? version of ocaml is going to have higher order modules and other fun things
<thelema>
oc4mc - it doesn't look like this will prod good things out of the dev team
<flux>
thelema, has ocamlviz been helpful for you?
<flux>
iirc you tried it out once?
<thelema>
flux: higher order modules? I thought it was lower order
<flux>
thelema, argh, I meant first class
<thelema>
flux: I'm using it for all my projects where I need to do profiling - ocamlviz is *awesome*
<thelema>
it's a bit bulky, syntax wise, but it's both pretty and useful
ttamttam has quit ["Leaving."]
<middayc>
what's wrong with oc4mc dev team?
<thelema>
middayc: I don't think they have the background to correctly achieve their goals
<thelema>
I'm happy at the success of their hack, but...
Camarade1Tux has joined #ocaml
Camarade_Tux has quit [Nick collision from services.]
Camarade1Tux is now known as Camarade_Tux
alp_ has joined #ocaml
bohanlon has quit [Remote closed the connection]
sramsay has joined #ocaml
ulfdoz has joined #ocaml
<middayc>
well at least it's a start which hopefully can evolve to something better if it's not yet .. (I don't know much about it or who made it)
gim has quit [Read error: 110 (Connection timed out)]
gim has joined #ocaml
<flux>
I don't think the authors themselves thought they'd make a product out of it
<flux>
but rather to show what is possible
<flux>
for example the architecture allows pluggable gc's, and while it's nice to have when evaluating different strategies, I'm guessing some performance is lost right there
ygrek has quit [Remote closed the connection]
<thelema>
I'm just suggesting the path they took doesn't lead much farther than where they arrived
monipol has left #ocaml []
ygrek has joined #ocaml
<middayc>
I see Xavier talks a lot about concurrency on that video
<thelema>
yes, there's a lot of people pushing for concurrency in ocaml, while xavier's position has been "multicore will exceed SMP" soon - don't worry about efficient smp
<mrvn>
and what is the difference for the GC?
<flux>
I actually wonder that. while I believe there are going to be non-shared-memory MP's, I wonder if they'll be composed of many memory-sharing SMP's..
Amorphous has quit [Read error: 110 (Connection timed out)]
<mrvn>
non-shared-memory MP would be cloud computing.
<flux>
no, if the P's are interlinked with Very Fast buses
<flux>
in cloud computing the links are Very Slow..
<mrvn>
Still, nothing to do with smp vc multi core
<mrvn>
s/vc/vs/
<flux>
you can have a multi core system without shared memory?
<mrvn>
flux: I doubt that. That would be just multiple cpus on a single die.
Amorphous has joined #ocaml
<thelema>
mrvn: network processors have gone with the "lots of cores in a single die", IIRC
<flux>
mrvn, heard of NUMA? that's already half way there.
<mrvn>
thelema: and how many 0.000000x% marketshare do they have?
<mrvn>
flux: still shared memory.
<flux>
mrvn, how large marketshare do they have of 64+-core machines?-P
<flux>
(just guessing that they scale higher, no idea really :)
<mrvn>
flux: With 4x 8core systems coming on the marked not so much soon
<mrvn>
And 2 years ago they had a 64 code mips system.
bzzbzz has quit ["leaving"]
<flux>
I wonder what kind of memory system tilera has
<mrvn>
anyway, shared memory multi core systems are the absolut standard for cluster and are becoming standard for home systems even.
<mrvn>
market share wise
<mrvn>
ocaml has to learn to use more than one core or it will loose against other languages.
seanmcl has joined #ocaml
<flux>
I'm thinking a shared-memory primitive that wouldn't be able to store other than basic datatypes would serve fine for high-performance calculations
<flux>
while actual control logic and objects could behave under 'shared nothing'
<flux>
there are certain advantages of having a simpler gc. such a gc is automatically parallel too and doesn't stop the world.
<mrvn>
What I'm wondering is wether one can make the compiler find out where data structures are shared between threads (and need locking) and where they are limited to a single thread.
<mrvn>
Also impacts the GC. Where does it need to check other threads memory and where can it just run locally
Yoric[DT] has joined #ocaml
willb has quit [Read error: 110 (Connection timed out)]
<thelema>
mrvn: marking values as thread-local and shared?
<mrvn>
thelema: but at compile time
<flux>
some kind of runtime-tainting could work
hcarty has quit [Read error: 60 (Operation timed out)]
<flux>
everything starts as thread-local and if you pass if to some function with potential to copy it elsewhere, it's shared from thereon
hcarty_ has joined #ocaml
<flux>
I don't know if this kind of analysis is helpful for gc, though
<flux>
for compile time information something like linear typing sounds useful..
<mrvn>
Consider something like List.rev (List.fold_left ...)
<mrvn>
The intermittend list is absolutely local and the GC can quickly free it wihtout having to halt other cores.
<mrvn>
Or Hashtbl. If it is in a single thread it doesn't need to lock the table.
<mrvn>
flux: as for tainting things at runtime I would think it could be usefull to have a 3-color GC with one color field per core. Run one GC per core and if all GCs color the item unreachable you free it
<mrvn>
doesn't scale well to many cores though.
<thelema>
256 cores -> 4 words of gc overhead per object?
<thelema>
or is that 8 64-bit words
<mrvn>
512 bit
<thelema>
8 words per value. ick
<mrvn>
think more of 2-8 cores
hyperboreean has quit [farmer.freenode.net irc.freenode.net]
bacam has quit [farmer.freenode.net irc.freenode.net]
tiz_ has quit [farmer.freenode.net irc.freenode.net]
M| has quit [farmer.freenode.net irc.freenode.net]
mattam has quit [farmer.freenode.net irc.freenode.net]
schme has quit [farmer.freenode.net irc.freenode.net]
acatout has quit [farmer.freenode.net irc.freenode.net]
peddie has quit [farmer.freenode.net irc.freenode.net]
orbitz has quit [farmer.freenode.net irc.freenode.net]
peddie_ has joined #ocaml
schme has joined #ocaml
bacam has joined #ocaml
orbitz has joined #ocaml
acatout_ has joined #ocaml
mattam has joined #ocaml
tiz has joined #ocaml
hyperboreean has joined #ocaml
<thelema>
Intel IXP2800 - 16 MicroEngines w/ 8 cores each
M| has joined #ocaml
<thelema>
each core has 640 words of single cycle memory
<mfp>
<flux> I'm thinking a shared-memory primitive that wouldn't be able to store other than basic datatypes would serve fine for high-performance calculations -> like BigArray ?
<flux>
mfp, yes
<mfp>
w/ everything else using thread-local storage, right?
<flux>
and I suppose bigarrays can be shared with mmap already
<mfp>
yes
<flux>
it's not easy to pass shared memory regions to other processes, is it?
<thelema>
what's missing? Examples and libraries?
<mfp>
BigArrays? you just fork & access them
<flux>
mfp, yes, if you've decided upfront the size etc
<flux>
an Event-module for multi-processing would be nice. did CoThreads give something like this?
<thelema>
hashtbl implemented on top of a bigarray?
<flux>
cothreads.sf.net is empty :/
<flux>
thelema, that would be interesting, with some locking primitives of course
<mfp>
well, if you want to parallelize computations over a BigArray, you can just fork once you have the array
<thelema>
there's some impressive work on lock-free hashtables
<flux>
mfp, but let's say you process images in a stream-like fashion
<flux>
mfp, you perhaps want to create a new BigArray for each incoming image
<mfp>
so, what's the pb?
<flux>
mfp, and pass that handle to each process that does some form of analysis
<flux>
mfp, so where do you create that array so other processes can access it?
<flux>
mfp, allocate one big array large enough and allocate parts of it runtime?
<mfp>
2 choices:
<mfp>
either you create the process once you have the bigarray (if the computation is not trivial the fork() overhead can be ignored)
<mfp>
or you don't mmap /dev/null and use some path instead, then pass it to an existent process
<flux>
well, that'd work
<flux>
but infact there's another solution too: mmap /dev/null and pass the fd's to other processes
<flux>
but there's no ocaml function (?) for doing that yet
<mfp>
sendfd is very sys-dependent
Associat0r has quit []
<flux>
but in general it can be done on unix systems.. dunno about windows.
<flux>
well, it would use some different mechanism there anyway
<flux>
you could also use sysv share memory if it came to that
<flux>
..a library would hide there things from you :)
<mfp>
the shmem limits are usually quite low
<flux>
dovecot uses fd-passing and apparently they've worked out the kinks
<flux>
(and there were some)
<mfp>
"Dovecot is an open source IMAP and POP3 server for *Linux/UNIX-like* systems" (emph mine) hmm
<flux>
so, apparently it works on all modern operating systems.. (and again, on windows you'd do something completely different)
<_andre>
i guess now is a goot time to mention my ocaml-fd project at the forge :)
<flux>
excellent timing :)
seanmcl has quit []
<flux>
but does that work on 'all' oses?
<_andre>
only unixy ones...
<_andre>
i have no idea if windows even supports this concept
<_andre>
i should be going
<_andre>
later
_andre has quit ["leaving"]
slash_ has joined #ocaml
<middayc>
has anyone done any network programming with Lwt?
ttamttam has joined #ocaml
Ori_B_ has joined #ocaml
<middayc>
(Lwt of ocsigen fame)
r0bby_ has joined #ocaml
Asmadeus has quit [Remote closed the connection]
Ori_B has quit [Remote closed the connection]
r0bby has quit [Dead socket]
ulfdoz has quit [Connection reset by peer]
ulfdoz has joined #ocaml
middayc has quit ["ChatZilla 0.9.85 [Firefox 3.5.5/20091102152451]"]
Asmadeus has joined #ocaml
<mrvn>
flux: You just need a shared FD to create the same mappings
Xteven has joined #ocaml
<flux>
apparently /dev/zero-backed shm doesn't work on all platforms, so that might be troublesome for that fd-passing
<flux>
__marius__, it'd be nice if the ocamldoc of the lib was on the web page..
<flux>
sigh, _andre isn't here anymore
middayc has joined #ocaml
ulfdoz has quit [Read error: 60 (Operation timed out)]
Pimm has quit [Read error: 110 (Connection timed out)]
eldragon has joined #ocaml
robocop1 has left #ocaml []
csmrfx is now known as csmrfx0
deavid has quit [Remote closed the connection]
deavid has joined #ocaml
thrasibule has joined #ocaml
albacker has quit [Read error: 148 (No route to host)]
seanmcl has joined #ocaml
onigiri has joined #ocaml
Nepomuk has quit ["Leaving"]
valross has joined #ocaml
thrasibule has quit [Read error: 60 (Operation timed out)]
Pimm has joined #ocaml
ygrek has quit [Remote closed the connection]
thrasibule has joined #ocaml
seanmcl has quit []
slash_ has quit [Client Quit]
thrasibule has quit [Read error: 110 (Connection timed out)]
_unK has quit [Remote closed the connection]
ttamttam has quit ["Leaving."]
middayc_ has joined #ocaml
narugawa has joined #ocaml
narugawa has left #ocaml []
onigiri has quit []
ikaros has quit ["Leave the magic to Houdini"]
c0m_ has joined #ocaml
<c0m_>
'a -> (int -> 'b) .... function that takes a polymorphic type variable and returns back a function which takes an int and returns a different polymorphic type var, right?
seanmcl has joined #ocaml
munga_ has joined #ocaml
Yoric[DT] has quit ["Ex-Chat"]
middayc has quit [Read error: 110 (Connection timed out)]
<Camarade_Tux>
c0m_: yup
<c0m_>
thanks
<thelema>
wow, that'd be a wierd function to implement.
<Camarade_Tux>
yeah ;p
<c0m_>
For example, with polynomials, X 2 and Y 3 can be unified to Z6 by taking X = Z3 and Y = Z2.
<c0m_>
the numbers should be exponents
<c0m_>
but how can that be valid
<c0m_>
x and y could be different
eldragon has left #ocaml []
sramsay has quit [Read error: 110 (Connection timed out)]
<thelema>
c0m_: they must be different for x^2 = y^3