testcocoon has quit [Read error: Connection reset by peer]
Ptival has quit [*.net *.split]
Ptival has joined #ocaml
ulfdoz_ has joined #ocaml
ulfdoz has quit [Ping timeout: 245 seconds]
ulfdoz_ is now known as ulfdoz
testcocoon has joined #ocaml
cdidd has quit [Remote host closed the connection]
cdidd has joined #ocaml
cdidd has quit [Remote host closed the connection]
cdidd has joined #ocaml
tuor has joined #ocaml
tuor has left #ocaml []
emmanuelux has quit [Remote host closed the connection]
cdidd has quit [Read error: Connection reset by peer]
iratsu has joined #ocaml
othiym23 has quit [Quit: WeeChat 0.3.6]
othiym23 has joined #ocaml
BiDOrD has joined #ocaml
BiDOrD_ has quit [Ping timeout: 252 seconds]
othiym23 has quit [Quit: WeeChat 0.3.6]
othiym23 has joined #ocaml
othiym23 has quit [Client Quit]
othiym23 has joined #ocaml
Hussaind has joined #ocaml
Hussaind has left #ocaml []
mjonsson has quit [Remote host closed the connection]
phao has joined #ocaml
pippijn has quit [Ping timeout: 252 seconds]
dsheets has quit [Ping timeout: 240 seconds]
greggies has joined #ocaml
eni has joined #ocaml
cdidd has joined #ocaml
mehdid has joined #ocaml
osa1 has quit [Quit: Konversation terminated!]
phao has quit [Quit: Not Here]
Anarchos has joined #ocaml
mehitabel has quit [Ping timeout: 244 seconds]
mehitabel has joined #ocaml
mehitabel has quit [Ping timeout: 245 seconds]
mehitabel has joined #ocaml
Sablier has joined #ocaml
Hussaind has joined #ocaml
Hussaind has left #ocaml []
cdidd has quit [Remote host closed the connection]
cdidd has joined #ocaml
cdidd has quit [Remote host closed the connection]
Yoric has joined #ocaml
Yoric has quit [Ping timeout: 245 seconds]
cdidd has joined #ocaml
Anarchos has quit [Quit: Vision[0.9.7-H-090423]: i've been blurred!]
cyphase has quit [Read error: Connection reset by peer]
ulfdoz has quit [Remote host closed the connection]
ulfdoz has joined #ocaml
cyphase has joined #ocaml
cdidd has quit [Remote host closed the connection]
cdidd has joined #ocaml
Tobu has quit [Ping timeout: 248 seconds]
cdidd has quit [Remote host closed the connection]
pippijn has joined #ocaml
phao has joined #ocaml
<phao>
which is a good place to start learning ocaml?
<mfp>
phao: a quiet one where you can read e.g. files.metaprl.org/doc/ocaml-book.pdf ? ;-)
<phao>
haha
<phao>
=D thx mfp
<phao>
mfp, do you use ocaml for producing software?
<phao>
professional, or large free software ones ?
<phao>
any sort
<mfp>
free sw., and stuff I'm going to try to monetize
<phao>
is it working?
<foocraft>
Haha, phao :p
<mfp>
latest open source stuff I wrote (to be released) = a database server
silver has quit [Read error: Connection reset by peer]
<foocraft>
findlib. Anyone had problems getting that to work?
<foocraft>
How can I modify the repository it sees?
<mfp>
phao: it doesn't segfault if that's what you mean ;-)
<phao>
=)
<phao>
I meant about the money thing
<phao>
it's very rare to find people who can work with "superior" lanugages
<phao>
meaning not cobol, c++, java, delphi, ... those.
<foocraft>
I am coming to ocaml from sml, looks pretty similar.
<foocraft>
I'm trying to write a naming server as my first project(a key value store), then I'd use that for a distributed file system I want to implement, all in ocaml
<mfp>
phao: haven't come to that point yet (-> early larval stage)
silver has joined #ocaml
<foocraft>
So, findlib. The guide is very ambiguious to me when it comes to letting ocamlfind aware of other packages that aren't installed with ocaml
<foocraft>
If I want to install ocaml_ssl using findlib, doing ocamlfind list doesn't show ocaml_ssl. How can I make it show up there? should I extract the files in one of the search paths that come out when I do ocamlfind printconf?
<foocraft>
If so, what's the point of ocamlfind? (which makes me doubt that copying files manually is the way to go)
<foocraft>
The guide doesn't show this well though(sorry if it's obvious somewhere in the docs, it's just that I haven't found any mention of that as I was reading through them)
<mfp>
foocraft: ocamlfind install essentially copies the files to the appropriate places along with a META file thas describes the package
<foocraft>
so it's ocamlfind install $name_i_pick $some_META_file ?
<foocraft>
It looks too daunting, sorry if this is all too obvious and I'm not seeing it clearly.
<foocraft>
the manpage that is.
<mfp>
for instance ocamlfind install META foo.cmi foo.cmx
<foocraft>
so, I'll try installing ocaml_ssl. I start of by downloading the package. sec.
<mfp>
sorry, I meant ocamlfind install PACKAGE_NAME META foo.cmi foo.cmx
<foocraft>
cmi cmx. What are those files?
<foocraft>
That should be in the docs, I'll check it out
<foocraft>
but lets try this first ocaml-ssl example. so in src/ I see the META file and in the whole directory tree of ocaml-ssl there's no cmi file
<foocraft>
and no cmx file too
<mfp>
these are the result of the compilation process
<mfp>
.cmi -> interface (foo.cmi has to be visible to the compiler if you have code that uses module Foo)
<foocraft>
actually, heh, ocaml-ssl's README says I should run the configure script which isn't in the directory
<mfp>
but there should be some make target to do all this
<mfp>
if there's a META included in the package
* mfp
takes a look
<mfp>
foocraft: right, according to README, the process is ./configure && make && make install
<mfp>
well, sudo make install
<mfp>
the latter will call ocamlfind for you
<foocraft>
oh, okay :)
<foocraft>
okay, so I guess ocamlfind is not some sort of automated package retrieval and installation system, it's just there to install a package and specify how packages are "installable"
<foocraft>
it's not like pip for python, for instance
<mfp>
right, the high-level equivalent would be something like odb
<foocraft>
Thanks. I'll fetch that and use it from now on
<foocraft>
(if it doesn't blow in my face, that is)
<foocraft>
So, mfp, your database solution, is it a key-value store? I'm trying to make a distributed key-value store for use in naming for any distributed project I'd be making
<mfp>
I'm surprised to see that archlinux has got so few ocaml packages (basically the compiler and findlib?)
<foocraft>
yeah, and something else
<foocraft>
extra/llvm-ocaml 3.0-4 OCaml bindings for LLVM
<foocraft>
extra/ocaml 3.12.1-3 [installed] A functional language with OO extensions
<foocraft>
extra/ocaml-compiler-libs 3.12.1-3 Several modules used internally by the OCaml compiler
<foocraft>
but meh. I'd rather be compatible with most ocaml users and it's a way to get me to use ocamlfind-style files for my packages
osa1 has joined #ocaml
<foocraft>
Sweet. I dig odb. :>
ftrvxmtrx has quit [Ping timeout: 250 seconds]
ftrvxmtrx has joined #ocaml
<phao>
mfp, the sort of software you wanna monetize... what is it? web app? game?
<phao>
CAD software?
<mfp>
phao: simplified file sync + version control system
<mfp>
phao: think dropbox meets git
gnuvince has quit [Quit: C-x C-c]
<mfp>
phao: are you evaluating OCaml for a project of yours?
<phao>
no
<phao>
just wanna learn because it looks cool
<phao>
interesting, nice, better than C++, etc.
<zorun>
mfp: fully decentralized, or is there a central server?
<mfp>
zorun: there's a central server
cdidd has quit [Remote host closed the connection]
<mfp>
zorun: in its simplified version control model, conflicts are always resolved trivially by creating 2 files (same way dropbox does), with some magic to handle move + edit and such cases correctly ("intention preserving")
<mfp>
zorun: things got way too hard when I tried to go fully distributed
<zorun>
yeah, I know, I'm working on something similar :)
<zorun>
mfp: but I took off the version control feature I was planning :/
<zorun>
it's too complicated without a central server
<mfp>
zorun: something similar, really? commercial or free?
<zorun>
only a project I started with friends, and it became a project for school afterwards :)
<zorun>
but I needed some features it doesn't implement
<zorun>
(for instance, bittorrent-like bandwidth optimization for low-bandwidth nodes)
eikke has joined #ocaml
greggies has quit [Ping timeout: 245 seconds]
greggies has joined #ocaml
cdidd has joined #ocaml
Submarine has quit [Quit: Leaving]
ftrvxmtrx has quit [Ping timeout: 244 seconds]
ulfdoz has quit [Ping timeout: 260 seconds]
<mrvn>
zorun: s/optimization/accumulation/
<zorun>
mmh
<zorun>
mrvn: in that case, all nodes have a full copy of the data
<zorun>
so when a node writes something, it has to be propagated
cdidd has quit [Remote host closed the connection]
<zorun>
doing that efficiently is what I called "optimization" :)
<mrvn>
zorun: viral propagation
eni has quit [Ping timeout: 245 seconds]
<zorun>
mrvn: what do you mean?
<mrvn>
zorun: A sends the data to B+C (infects them), B sends to D+E, C to F+G, ... and so on.
<zorun>
basically, yes
<mrvn>
Gives you an exponential increase in the speed the new data gets distributed
<mrvn>
just like a virus
<mrvn>
One thing you should think hard before you start: Does every node need all the data? Or don't just need enough copies of the data to ensure it remains available?
<zorun>
yes, erasure coding
<zorun>
tahoe does that
<zorun>
but it adds complexity
<mrvn>
But having 1000 copies of your data is rather wastefull.
<zorun>
true
<zorun>
the current use-case is much smaller than that, however :)
<zorun>
it's probably come later
<zorun>
*it'll
<mrvn>
It's a matter of what scale you want to use. If you are more like 10 nodes all which are closely controlled and won't just randomly disapear you can do stuff a lot different.
<zorun>
no, it's about ~ 10 nodes that belong to different persons, that communicate over low-uplink channels (ADSL) and that are not reliably always available
<mrvn>
In a small trusted set you don't have to watch for abuse and you can optimize paths according to bandwiths (send the data to a fast node first and have it spread it)
<zorun>
the point is that there's no fast node :)
<zorun>
I want to experiment what's possible in this case
<mrvn>
all equal speed is valuable information too
<zorun>
all nodes have equally low uplink
<zorun>
yes
ulfdoz has joined #ocaml
<mrvn>
You can also optimize what you upload. Say you upload Block 23 to node A then it makes no sense to also upload Block 23 to node B, it can get it from A.
<mrvn>
Unless there is no other block to upload. then you repeat older blocks.
<mrvn>
With such a small set you can maintain perfect knowledge of which blocks each node has and have each client figure out an optimum dispersal pattern for new data.
<zorun>
I started like this
<zorun>
but it requires an accurate knowlege of the bandwidths on all links
<mrvn>
which you have
<zorun>
bittorrent's way of doing things might not be optimal, but it works well
<mrvn>
or at least you will have past experience with each node quickly.
* Hodapp
looks in
<zorun>
(without knowing the underlying topology)
<Hodapp>
this looks like an interesting discussion.
<zorun>
:)
<zorun>
mrvn: "past experience"?
<mrvn>
zorun: how fast was the last block from that node.
<Hodapp>
but why am I here? I've used Scala a sum total of about 5 hours. I am learning Scala now.
<zorun>
mrvn: mmh, this sounds interesting
<mrvn>
zorun: There are 2 things that I think are quite suboptimal in bittorrent: 1) You upload to many clients in parallel. Would be better to upload one block to one client as fast as possible and then switch to the next client.
<zorun>
but it only works reliably if you're not sending/receiving anything else
<mrvn>
2) you upload data more than once preventing the recieving clients to exchange data.
<zorun>
regarding 1): for small blocks, the difference is not huge
<mrvn>
zorun: nah, sending/receiving something else just limits the bandwith of the node. changes nothing really.
ftrvxmtrx has joined #ocaml
<zorun>
and bittorrent blocks are between 16K and 32K
<zorun>
as for 2), if you mean than uploading the same data to different peers is counter-productive, then I agree
<mrvn>
zorun: No, blocks are 256k-8MB. You can download lots of 16k fragments of a block from many people but you need the full block before you can share it.
<zorun>
ah, yes, pieces are larger
<zorun>
true
<mrvn>
Also I think the 16k fragment size is wastefull too. Too much overhead to request those fragments on faster connections.
<zorun>
for 2), I think most clients request random pieces
<zorun>
yes
ulfdoz has quit [Ping timeout: 245 seconds]
<mrvn>
zorun: yes. torrent clients are supposed to request random pieces. But you get collitions quickly. Birthday paradox.
<zorun>
mmh, on such a small network, maybe bittorrent's way is not the best, yeah
<zorun>
oh, ok
<mrvn>
What I think should happen is that the client says what pieces it has and then the sender decides what piece it sends. That way it can send pieces that it hasn't send anyone else.
<zorun>
actually, the greatest difference I see is that bittorrent is rather pull-oriented, while I want to do things the other way around (a node wants to push data to everyobdy)
<mrvn>
Further for a file with 100 pieces the seeder should "create" 1000 redundant pices using forward error correction methods and instead of sending a piece a second time send one of the redundancy pieces.
<zorun>
oh, that's a nice idea!
<mrvn>
And any client that manages to gather any 100 pieces can restore the file and then create its own different 1000 redundnacy pieces and send out those instead of repeating existing data.
<mrvn>
The drawback of that method is that you can't download just part of a file. You need to get 100 pieces to restore the file (or find exactly the original pieces, which might not exist on the net)
<mrvn>
But that would only be a problem in a large network.
<zorun>
err, I'm not sure that creating different redundant pieces is a good idea
<zorun>
since they won't get along very well with the pieces of the first peer
<zorun>
a peer might receive pieces both from the first and the second peer
<mrvn>
zorun: nah, the redundancy pieces have to be compatible. Basically you have 100 original and 64536 redundancy pieces and each clients uses a random subset from those 65536 pieces.
<zorun>
ah, right
<mrvn>
and you generate them as needed.
<zorun>
well, that was interesting :)
<zorun>
mrvn: have you already worked on such a project?
<mrvn>
zorun: just some ideas. Haven't had the time to start something like it.
ulfdoz has joined #ocaml
<Hodapp>
I don't know if this is related to the discussion at hand or not, but it does remind me of something a friend and I were talking about the other day when I mentioned how something like RetroShare works.
<Hodapp>
But... Are there any tools primarily for ad-hoc file sharing over a LAN, requiring little to no setup (i.e. capable of autodiscovery for most things)?
<mrvn>
I use sendfile
<mrvn>
meaning SAFT
<Hodapp>
We were looking for more pull- than push-based, I think.
<mrvn>
a torrent server is easy to start too. Or just simple http/ftp.
<Hodapp>
He was interested in doing some hashing on the contents to make it clearer what shared data was redundant (and perhaps do some distributed transfer taking advantage of this, the way BitTorrent does); HTTP/FTP make browsing easy, but not this.
<Hodapp>
And also in not having to worry about what host had the data, just that some host on the LAN had it.
<Hodapp>
In other words - very similar to how some P2P systems like LimeWire worked, but running on something less like Gnutella and able to initialize much faster and take advantage of an assumed-fast, assumed-secure LAN
<Hodapp>
...and also not possessed of very shady origins.
<Hodapp>
Sorry, this has nothing to do with OCaml, ML, functional programming, static typing, or type systems and programming in general.
<mrvn>
Obviously we would implement the whole thing in ocaml :)
<adrien>
mldonkey?
<adrien>
peerple?
<adrien>
(iirc)
<Hodapp>
ooh, thank you for both. I'll have to read on those.
cdidd has joined #ocaml
<adrien>
one day, the french lawmaker, in her infinite wisdom
<adrien>
has decided that P2P was a rude word
<adrien>
that it should be banned
<adrien>
that anyone doing anything P2P was commiting a criminal offense
<foocraft>
Swinger's party!
<foocraft>
-' haha
<adrien>
some of the developers of mldonkey, who were french, surprisingly, stopped touching mldonkey at once
<adrien>
at the same time, development on peerple was started
<adrien>
that's probably a very inacurrate story and some of the people involved are on the channel (not all the time) if you really want the exact story
cdidd has quit [Read error: Operation timed out]
phao has quit [Quit: Not Here]
struktured has joined #ocaml
<osa1>
I'm trying to install metaocaml to my system but I already have system-wide installed ocaml, is there a way to do that without deleting the current ocaml installation?
<thelema_>
osa1: probably - does the ./configure script have --prefix?
<adrien>
or single dash (maybe)
eni has joined #ocaml
silver_ has joined #ocaml
silver_ has quit [Read error: Connection reset by peer]
struktured has quit [Ping timeout: 244 seconds]
silver has quit [Read error: Connection reset by peer]
Submarine has joined #ocaml
<bokuk1>
hi..
<bokuk1>
i have a question.
<bokuk1>
ocaml have a different operator on the int and float type of the plus , minus ..
<thelema_>
yes, + vs. +.
<bokuk1>
but, '=', '<>' ..
<thelema_>
yes, = is magical
<bokuk1>
the same operator on the int and float
<bokuk1>
why?
<thelema_>
it looks at the runtime representation of values and can work that way
<thelema_>
but + can't figure out whether it has a float or int at runtime
<thelema_>
for =, it doesn't matter really
<bokuk1>
hmm....
<bokuk1>
i don't understand... why it figure out at runtime ? not compile time?
<pippijn>
= works for all types
<pippijn>
except functional values
<pippijn>
but even then, it will compile
<thelema_>
bokuk1: for example `let f a b = (a = b)` - this has to generate code that works for all types
<thelema_>
but `let g a b = (a+b)` needs to generate adding code for one specific type.
<thelema_>
bokuk1: I guess (=) could be not-magical, and then you'd need to build an equality function for all kinds of values
<adrien>
(=) is also very dumb
<thelema_>
and then specify which equality you meant, but frankly, this is a pain.
<thelema_>
adrien: it's not *very* dumb, it just doesn't know about which values should be considered the same.
<bokuk1>
ah....
<adrien>
I meant: it compares bits and walks down structures; I should have called it "simple" maybe
struktured has joined #ocaml
<bokuk1>
thanks thelema_
bjorkintosh has joined #ocaml
emmanuelux has joined #ocaml
wmeyer has quit [Ping timeout: 246 seconds]
osa1 has quit [Quit: Konversation terminated!]
<mrvn>
It's too bad that there isn't a =.= that is somewhere between = and ==, handles functions with == and everything else with == | =
<Kynes`>
it would also have the benefit of looking like a face
<pippijn>
mrvn: why shouldn't that be the default for =?
<flux>
yeah, I think that runtime-error isn't that beneficial
<mrvn>
pippijn: could be. But then functions would behave differently in <, > and =
<mrvn>
(fun () -> ()) = (fun () -> ()) would be false. Probably not what people would expect
<pippijn>
ordering could be its memory address
osa1 has joined #ocaml
<pippijn>
yeah, that's counter-intuitive
<mrvn>
pippijn: not with a compacting GC unless that preserves the order
<pippijn>
I don't know about ocaml, but microsoft .NET compaction does
<mrvn>
Does ocamls GC preserve the physical order on compaction?
<pippijn>
= on functions could compare the machine code or byte code
<mrvn>
yeah, it could compare the function block containing the address of the code and arguments.
<mrvn>
Never understood why ocaml doesn't do that
Tobu has joined #ocaml
emmanuelux has quit [Ping timeout: 264 seconds]
wmeyer``` has quit [Remote host closed the connection]
<bokuk1>
can you tell me about advantage/disadvantage than haskell?
<bokuk1>
hmm...
<mfp>
I'll go first: Haskell enforces purity, OCaml doesn't. OCaml uses strict evaluation by default, Haskell non-strict.
<bokuk1>
do you think non-strict is useful ?
Cyanure has joined #ocaml
<mfp>
I use OCaml so you can guess my answer :)
<bokuk1>
i am sorry my stupid question :-)
<mfp>
it is useful, but I prefer strict by default
<pippijn>
and lazy is not hard in ocaml
<bokuk1>
thank you.
osa1 has quit [Quit: Konversation terminated!]
<mfp>
other things: Haskell's GHC compiler performs many many optimizations OCaml's ocamlopt doesn't (it's not an optimizing compiler); OTOH, in practice idiomatic OCaml code is often faster than the Haskell equivalent, thanks to the sound compilation strategy.
<mrvn>
In ocaml you get what you write, in hashkell the compiler optimizations can screw you over from here to there.
osa1 has joined #ocaml
<bokuk1>
it is interesting. :-)
<bokuk1>
i think ocaml is good functional feature and very simple ( strict evaluation default). and not slow. but many people encourage haskell. i like ocaml , but i am confused that which i have to learn.
<pippijn>
I guess GHC wants to be a "sufficiently smart compiler"
<bokuk1>
i know it is a very stupid question .
<mrvn>
ocaml fits a nice coding practice: Less code means leass bugs.
<bokuk1>
:-)
<bokuk1>
i am sorry my poor english. it is a good advice for me. thanks a lot.
osa1 has quit [Ping timeout: 244 seconds]
Yoric has joined #ocaml
Yoric has quit [Ping timeout: 244 seconds]
bokuk1 has quit [Quit: 전 이만 갑니다.]
bokuk has joined #ocaml
bokuk has quit [Client Quit]
bokuk has joined #ocaml
hcarty has quit [Ping timeout: 244 seconds]
hcarty has joined #ocaml
osa1 has joined #ocaml
rgrinberg has joined #ocaml
bokuk has quit [Quit: 전 이만 갑니다.]
bokuk has joined #ocaml
wmeyer has joined #ocaml
<wmeyer>
hello
<adrien>
morning
<wmeyer>
:-)
osa1 has quit [Quit: Konversation terminated!]
struktured has quit [Read error: Operation timed out]
osa1 has joined #ocaml
<flux>
mrvn, regarding why not compare code: it would result in differening results between byte code and native code?
<flux>
altough for most code that wouldn't likely matter, but..
Submarine has quit [Quit: Leaving]
<bokuk>
i know it is good to write a game in c++. it is not good to write a game in ocaml than python? lisp? ( i am good to write in c++, but i i hate c++.)
bokuk has quit [Quit: 전 이만 갑니다.]
pango has quit [Remote host closed the connection]
pango has joined #ocaml
snearch has joined #ocaml
<orbitz>
Does anyone actually use pa_monad?
eni has quit [Read error: Operation timed out]
hcarty has quit [Ping timeout: 245 seconds]
hcarty has joined #ocaml
struktured has joined #ocaml
snearch has quit [Quit: Verlassend]
osa1 has quit [Ping timeout: 260 seconds]
osa1 has joined #ocaml
<orbitz>
does -pack only work for object files? What if I wan to make native?
<pippijn>
orbitz: I use it
<orbitz>
How do you like it?
<orbitz>
I havethis Either type I want to make easier ot work with
<adrien>
orbitz: in native code, you have to have used -for-pack first
<orbitz>
thanks
emmanuelux has joined #ocaml
eni has joined #ocaml
<pippijn>
orbitz: I like it
<pippijn>
orbitz: I use it in one place only
<pippijn>
orbitz: for the option type
eni has quit [Quit: Leaving]
<wmeyer>
orbitz: I use it for the state monad in DragonKit
<wmeyer>
orbitz: it's much easier to use monads that way
avsm has quit [Ping timeout: 244 seconds]
Anarchos has joined #ocaml
<pippijn>
wmeyer: that code looks really pretty
<wmeyer>
pippijn: thanks :-)
<pippijn>
I'm looking at llvm-example/codegen.ml
<pippijn>
nice
<wmeyer>
pippijn: but don't look at the monad implementation - is somewhat less pretty ...
<pippijn>
also a lot less relevant
<wmeyer>
pippijn: i made a great effort to avoid having an explicit state, and keep the data structures simple internaly and externally
<wmeyer>
pippijn: so the idea is that when you add instructions to the basic block you cons it to the begining of list
<wmeyer>
once you say end_block it reverses them and finalize the block
<pippijn>
sounds good
<wmeyer>
i think that this is the standard way how things work in Haskell
<pippijn>
yes
Sablier has quit [Quit: Quitte]
<wmeyer>
pippijn: i am actively working on the project, or say it on a side library around dragonkit - just i can't push the stuff right now to the github - for several reasons - but they will be follow up soon i hope
<wmeyer>
still people had asked to put some readme into the project - didn't have chance to put the idea together - especially that yet they are not that clear
<wmeyer>
pippijn: the side project is already size of dragonkit - I hope to replace backend parts with it
<pippijn>
:)
<wmeyer>
it will also be not a pure llvm copy :-)
<wmeyer>
but somewhat beyond tht
<wmeyer>
but i also hope to parse llvm ir and convert it to "flat" language
<wmeyer>
that would give me a chance to use exisiting frontend infrastrctures
<wmeyer>
pippijn: it's already about 3KLoC dangling in my git somwhere - that come just last month
<pippijn>
by the way, x86backend.ml has "liveness.ml" as its title
<pippijn>
=> don't put the filename into the file
<wmeyer>
pippijn: other parts might be crufty too...
<wmeyer>
but x86backend.ml will be completely autogenerated :-)
<wmeyer>
maybe even that week i will commit the generated code - as i am not able to publish the tool
<wmeyer>
sorry - x86encode.ml
<wmeyer>
backend will probably be seriously rafactored
<wmeyer>
not being able to publish = it's not ready
<wmeyer>
pippijn: yes, I try to keep it tidy.. but DragonKit probably will be reworked soon - some of the things are really stupid in my framework
<wmeyer>
as a proof of concept it seems to work
<wmeyer>
possibly tomorrow i might start looking at the register allocator
<pippijn>
have you thought of using BURS for codegen?
<wmeyer>
pippijn: I have hear about it - I have similar idea - feed enough information to backend and architecture to literally generate the backend
<wmeyer>
that's what my "side project" meant to do :)
<wmeyer>
but BURS does not seem to be well documented ...
struktured has quit [Read error: Operation timed out]
<wmeyer>
pippijn: but yes you are right - i want to propose something that is significanlty better than llvm tablegen or mlrisc md, and conceptually different than LLVM
<pippijn>
BURS is like pattern matching with weighted cases
<wmeyer>
itself
<wmeyer>
that sounds like what i wanted - but extend it with contraint solver
<wmeyer>
sometimes you need more than just pattern matching
<wmeyer>
especially you are going from tree to sequence - now there are many ways of doing that
<wmeyer>
in fact we are being constantly hit by the *micro architecture* differences
<wmeyer>
having a decent number of instructions
<wmeyer>
and complex dependencies between them to achieve the performant code (or size optimised)
<wmeyer>
some of the stuff can be as less efficient across micro architectures as 20% for the same sequence but running on a different CPU
<wmeyer>
(different CPU but same architecture)
<wmeyer>
at some point when you perform this micro optimisations you will end up on edge what is possible to do, and then really highlevel optimisations kick in make sense, where ML can really shine, like partial evauation or supercompilation
<wmeyer>
still it;s way easier to perform this stuff if you have a language which is dominated by values (e.g any functional language) rather than with mutation and pointer and (C)
<wmeyer>
it makes so much effort to support all this imperative crap, volatiles, pointer aliasing, weak type system etc.
<wmeyer>
anyway :-)
phao has joined #ocaml
Cyanure has quit [Ping timeout: 252 seconds]
wmeyer has quit [Ping timeout: 245 seconds]
phao has quit [Read error: Connection reset by peer]
phao has joined #ocaml
Anarchos has quit [Quit: Vision[0.9.7-H-090423]: i've been blurred!]
Anarchos has joined #ocaml
hcarty has quit [Remote host closed the connection]