freenode/#sicl - IRC Chatlog
Search
22:39:40
Gnuxie[m]
just popping in to say that I've pushed some of my changes (additions) to a fork of Cluster (since I think github might notify people and stir curiosity), they're not really ready for review yet and I've been a bit unwell but I'm happy with how it's progressing
22:42:34
Gnuxie[m]
basically I've added some 'meta' to generate the tables for a small decoder/interpreter to use and so far I'm going for it to be built in such a way that I will identify the instruction descriptor first and use that to figure out how to decode the operands and any intricacies with the modrm byte and such
22:45:17
Gnuxie[m]
so we can go as specific as an instruction by instruction basis for decoding if for some reason there's some really odd stuff further up the road
22:52:17
Gnuxie[m]
at the moment I'm also going to generate a class to use for the interpreter state, like which prefixes have been collected and their values (for the case of rex) because the interpreter needs to understand prefixes to select final instruction descriptor candidates when it's exhausted the opcodes
22:52:39
Gnuxie[m]
the purpose of doing it this way is so that no one has to update any interpreter code when they add a new instruction descriptor
22:53:57
Gnuxie[m]
atm the way i'm seeing it is not very complex, just a simple remove operation for each remaining candidate that doesn't match the prefixes the interpreter state has and such
3:55:04
no-defun-allowed
Is there a point to getting a CS degree? Somehow this second first year is more depressing than my first first year.
3:58:40
beach
If you want to do what you like to do yourself and you want someone else to pay for that, a CS degree is a must.
3:59:14
beach
If it is fine with you to work on something that other people decided, then it is not a requirement.
4:04:16
no-defun-allowed
Much like last year, most of my time is spent cleaning up template code to a point where the solution for the work provided is quite straightforward. So it is a perpetual code cleanup job.
4:06:23
beach
The way I see it is that this is something you have to do for a few years so that you can do something you want for 4-5 decades.
4:06:45
beach
Whereas if you don't do this now, someone else will decide what you should do during those decades.
4:08:44
no-defun-allowed
And then I have to double check any information provided. In the context of databases, the descriptions provided don't match up with the data provided; and they provide misinformation like "you should construct a SQL query by joining strings together" which I have to figure out how to avoid.
4:12:26
beach
I learned a lot myself, but I was very lucky. My teachers were working in the group of Erik Sandewall.
4:18:25
beach
I see a CS degree as an international insurance policy. The higher the degree, the better coverage.
4:54:24
Bike
how common do you think code that calls a function in one branch and applies it in another is? like (if x (f y) (apply #'f z)) sort of thing.
4:55:46
beach
Probably not common, but it can definitely happen. The test determines whether the arguments are known. Why do you ask?
4:57:43
Bike
i'm putting in some multiple value related optimizations. sbcl translates apply into multiple-value-call, and you could translate a regular call as a multiple value call too. so you could hypothetically do that and contify.
4:58:53
Bike
the apply->mv-call thing might be nice for call-next-method, since then the apply turns into a local call and no closure gets consed
5:02:08
moon-child
Bike: I think a more common pattern is (apply #'f (if x (list y) z)). But maybe that's just my urge to factor everything
5:02:39
Bike
other than when you can determine the number of values exactly, in which case you should probably make it a regular call
5:04:31
Bike
the multiple-value-bind to multiple-value-setq is effectively a special case of inlining a multiple value call, and that seems useful enough
5:04:49
Bike
though actually inlining/interpolating the function appears to be less important to performance than just avoiding consing a closure
5:06:21
Bike
multiple-value-call is of course rare in itself, but apply is common and is kind of the same issue, i.e. calls with variable arguments
5:06:51
Bike
some things could be useful... for example if you apply a function, and you know the lambda list, and the apply's list argument is the function's &rest argument, you could just inline pretty straightforwardly
5:11:12
Bike
the gain of being able to apply a local function without forcing it to cons is probably bigger than anything trickier like that
5:11:38
Bike
assuming multiple-value-call is fast enough for that to be efficient. i don't think there's any reason for it not to be, but i'll have to check what it looks like on clasp
6:38:42
no-defun-allowed
Take an estimate and add a month. If it hasn't been released by then, just try again with that date.
6:40:15
beach
nij: We *hope* to have a native executable this year, but there is no guarantee, and even if we do it, it won't be optimized, so not suitable for production use.
7:48:12
beach
We need to write a simple call-site manager, but that's no harder than the implementation of the FUNCALL-INSTRUCTION.
7:49:51
beach
We need to create an ADDRESS function that takes an object and returns its address. In the native executable, it will do exactly that, but during bootstrapping, it allocates space for the object in a (simulated) global heap and return the address that it was given there, unless of course, it already has an address there.
7:50:28
beach
The call-site information needs to be improved so that the call-site manager can exploit it.
7:51:06
beach
And we need to load tons more code like Eclector and the compiler phases. This task will be simplified when we allow arbitrary ASDF systems.
7:52:05
beach
Well, to load all those modules, we will likely have to implement some missing features, but there shouldn't be too many of those.
9:28:15
beach
I think I was able to configure ASDF to load SICL source files into bootstrapping environments.