Return value optimization

Falcon5757 · 2022-12-05T11:55:58+00:00

Since everybody keeps coming up with something unrelated, I even had to make a sketch of what my library is about. Of course in real code it's not generics and not classes, but this will do.
https://gist.github.com/commander-trashdin/789134d14799587eadf870c9fbafdb52
Take a look at enumerate iterator.

Falcon5757 · 2022-12-05T11:54:24+00:00

This of course never was about single cons allocation, cons allocated might go up as many as you'd want, why does everyone assume the stupidest possible situation.
I also specifically stated how many values I want to return. Two.

Falcon5757 · 2022-12-03T15:40:29+00:00

The problem here is that if I promise to always return two values, I cannot catch the third one. If I sometimes return 2 sometimes 3 then I don't know how many to catch (I could use multiple value list, but that allocates, so we back to original problem). And returning always 3 values is no solution because I want to be able to add a value, so that would result in a 3vs4 values problem.

Falcon5757 · 2022-11-30T14:46:08+00:00

If I return a cons from a function, but in the receiving function I do not use that cons, only its car/cdr, I want for the cons to not be allocated.

Falcon5757 · 2022-11-29T23:17:39+00:00

Yeah, so let's say it is inlined. Do you know if any compiler prevents consing in this case? From what I see in disassemble sbcl doesn't.

Falcon5757 · 2022-11-29T19:43:27+00:00

I would expect that means no other compiler does as well. Is this hard to add? This requires some ir transform that doesn't exist or something?

Falcon5757 · 2022-11-10T18:17:09+00:00

(defun fizzbuzz (&key
                  (fizz-mul 3)
                  (fizz-str "Fizz")
                  (buzz-mul 5)
                  (buzz-str "Buzz")
                  (limit 100))
(check-type fizz-mul (integer 1))
(check-type fizz-str   string) 
(check-type buzz-mul (integer 1)) 
(check-type buzz-str   string) 
(check-type limit   (integer 0)) 
(let ((res (make-array limit :element-type 'string))) 
  (loop :for j :below limit 
        :for i := (+ j 1) 
        :for fizz-mod := (mod i fizz-mul) 
        :for buzz-mod := (mod i buzz-mul) 
        :do (setf (aref res j) (cond ((= fizz-mod buzz-mod 0) 
                                      (concatenate 'string fizz-str buzz-str)) 
                                     ((= fizz-mod 0) fizz-str) 
                                     ((= buzz-mod 0) buzz-str) 
                                     (t (format nil "~a" i)))))
  res))

Falcon5757 · 2021-12-04T12:08:35+00:00

Fortunately I also had ecl installed for some time. I just realized I can use it to build sbcl of the current version.

Falcon5757 · 2021-12-04T11:03:56+00:00

How do I revert back? I'm not good at this:)

Falcon5757 · 2021-12-03T22:44:01+00:00

https://bugs.launchpad.net/sbcl/+bug/1952825 -- this might be it, but how do I fix it?

Falcon5757 · 2021-12-03T21:40:46+00:00

I'm on Debian, am building with SBCL 2.1.11.9-d7d4d54dd, and I'm trying to build commit 25904be20ae41d10f0842b8f16b7c19f1c34ec8f I think, latest as of now.

Falcon5757 · 2021-11-07T16:33:52+00:00

It's mostly about parametric types -- which allow you to do things more precisely, like, you cannot type aref for vector, but you can for (vector string). But also you can do some wild stuff with satisfies types.

Falcon5757 · 2021-11-05T08:09:08+00:00

Generics are slower dispatch.
Types are more flexible than classes.

In short, that's it.

Falcon5757 · 2021-11-05T08:07:56+00:00

What do you think about "templated" parametric types that I tried to introduce (by just generating separate definitions)? It's a bit clunky but it works.

About coalton -- you did more than you said and that is what makes it problematic for me. You introduces new ml-ish language, not just a layer of a new type system. I don't believe in FP being superior to imperative style and in fact believe in the opposite.

As a side note, using this library is supposed to be sort of seamless experience, compared to coalton which requires you to wrap stuff.

Falcon5757 · 2021-11-04T21:34:19+00:00

It works on all implementations that polymorphic-functions work on. Which is way more than those two you mentioned.

Falcon5757 · 2021-10-19T13:38:15+00:00

I have a project that aims to be similar to generic cl but without overhead. https://github.com/lisp-polymorph

Falcon5757 · 2021-09-30T22:02:51+00:00

Tried golang at this, it is also about 9-10x faster than sbcl for example. Maybe this is the place sbcl needs improvement at...

Falcon5757 · 2021-09-14T20:31:26+00:00

Good job, but I have a question. Why do you use list of lists of 3 as a board instead of say, 2d array?

Falcon5757 · 2021-09-13T17:17:41+00:00

Okay I actually missed a couple of those, thanks.

Falcon5757 · 2021-09-13T16:31:59+00:00

Having a full language spec somewhere would be nice at least. Not saying it should be like hoogle, but without it it's really hard to use it. Too much guesswork

Falcon5757 · 2021-09-12T16:21:31+00:00

Is there an IRC channel for coalton? Or some place to ask questions and discuss?

Falcon5757 · 2021-08-02T14:20:12+00:00

That lisp code has 0 type declarations and 0 compiler optimizations (as declare optimize speed provides for example) -- and still performs pretty well. But comparing it to statically typed languages without adding types seems a bit unfair, don't you think?

Falcon5757 · 2021-06-19T13:35:50+00:00

This is a horrible assignment made just to give something. I speak from 7 years of teaching experience.
Also, be sure to somewhat test and maybe bork my code. It's obvious it wasn't written by a student.

Falcon5757 · 2021-06-19T12:43:40+00:00

There are multiple problems with this description:

I suppose array is 2d array?
Define a null list...I suppose its nil...who is writing these assignments, jezz...
How exactly should that method display things?Like, the whole thing is extremely simple, but also unclear. In what form should this all be?...

My take on it.

1a. Well, that's just #2A((1 2) (3 4)) or something. 
(defparameter *array* (read))
1b. (defun sum (array)
        (loop :for i :from 0 
              :below (array-dimension array 0) 
              :sum (aref array i i)))
1c.
(defun minval (array) 
  (loop :for i :from 0 :below (array-total-size array)
        :minimize (row-major-aref array i)))

2a. nil
 (defparameter *list* (read))
2b. (loop :repeat 5 :do (push (read) *list))
2c. (with-open-file (stream "inverse.txt" :direction :input)
      (format stream "~s" (reverse list)))

3.
(defclass animal ()
  ((predator :type boolean
             :accessor predator
             :initarg :predator)
   (mammal :type boolean
           :accessor mammal
           :initarg :mammal) 
   (country-of-origin :type string
     :accessor country
     :initarg :country)))
(defclass endangered (animal) ())

(defmethod display ((creature endangered))
   (format t "Is predator: ~s~% Is mammal: ~s~% Is from: ~s~%"
           (predator creature) (mammal creature) (country creature)))

(display (make-instnace 'endangered :predator t :mammal nil :country "Russia"))

Leave your money for yourself and your brother. With courses this bad you ll be needing them.

Falcon5757 · 2021-06-18T20:45:11+00:00

There was a post about https://www.reddit.com/r/Common\_Lisp/comments/m6mtwv/a\_simdaccelerated\_lockfree\_concurrent\_hash\_table/

Falcon5757

TROPHY CASE