03:39 <azot> I wonder, how could one export a directory from an opam repository, to which one could opam pin later?

03:40 <azot> I performed a direct copy from ~/.opam/repo/default, but the package is refusing to fetch sources when after I opam pin the copy.

07:38 <azot> I also wonder, what would be the best way to request a native-only build from dune?

12:54 <d_bot> <Lupus> is it possible to figure out how many memory was allocated for bigarrays? ideally some way that can be used to expose this metric for monitoring 🙂 this is not accounted in the OCaml heap, we have large memory utilization in one of services and trying to figure out where is it coming from - bigarrays or from some other native library

12:57 <d_bot> <Drup> `Obj.reachable_words` doesn't work ?

12:57 <olle> gdb?

12:57 <d_bot> <Drup> (bigarrays are pretty easy to count the size, though, you could just compute the size and the wordsize of each element)

12:57 <d_bot> <EduardoRFS> there is any "safe" way to split a block in two? If I have a bytes sequence with a OCaml block inside of it, is it okay to change the size of the block on the header and then point to the top of the block?

12:58 <d_bot> <EduardoRFS> like, I did this already, but I want to understand the implications of it

12:58 <d_bot> <Drup> @EduardoRFS With `Obj.truncate`, or with another method ?

12:59 <d_bot> <EduardoRFS> using FFI, I changed the header of the bytes array and pointed out to the block at the end of the bytes

13:01 <Armael> isn't Obj.truncate deprecated now?

13:02 <d_bot> <Lupus> hm, I don't have a list of my bigarrays available, I just know that there are a lot of them and I want to know how much memory all those actually occupy

13:03 <octachron> The 4.12 version of statmemprof allows to track the allocation of custom datatypes, including bigarrays

13:26 <d_bot> <Lupus> is statmemprof that new mechanism that memtrace uses?

13:28 <d_bot> <Lupus> we can repro the issue locally, so we'll just use valgrind massif to track it down, but this is not always feasible and would be awesome to be able to measure off-heap data allocations done by services via bigarray/bigstring...

13:33 <octachron> Yes, memtraces is using statmemprof

13:33 <hannes> Lupus: yes, statmemprof is used by memtrace. only since 4.12 (atm in beta) bigarrays are tracked there - if you use 4.11 you won't see bigarrays.

13:42 <olle> maybe try caml_alloc?

14:00 <d_bot> <Lupus> cool, sounds awesome! we're on 4.11

14:03 <d_bot> <Lupus> massif shows that those are bigarrays that occupy a lot of memory...

14:03 <d_bot> <Lupus> is there some additional GC weight associated with bigarrays? or GC seems those as just small objects and thus considers major heap not worth collecting?

14:03 <d_bot> <Lupus> *sees

14:28 <d_bot> <octachron> Normally yes, the GC is (partially) aware of the amount of out-of-bound memory used by custom value: https://ocaml.org/manual/intfc.html#ss:c-custom-alloc

14:44 <d_bot> <Lupus> thanks for the pointer @octachron !

14:45 <d_bot> <Lupus> that's great 🙂

16:55 <d_bot> <Icemasta> Not exactly ocaml related but I am wracking my brain against this

16:57 <d_bot> <Icemasta> I have an array of X elements, Y of which are TRUE, Z of which are FALSE. I cannot know what the content of this array, all I can do is call a compare function which returns TRUE if both elements of the array are identical, or false if they aren't.

16:57 <d_bot> <Icemasta> Now I've done the usual brute force solution, which works, but I feel there could be a fancier way of doing this

16:59 <d_bot> <Icemasta> At first I also thought about dividing it, so like if I got 100 elements, it would be split into 2 groups of 50, and then 4 groups of 25 and so on

16:59 <d_bot> <Icemasta> But in the end this is just brute force solution with extra steps

17:01 <d_bot> <octachron> Note that you have not described what you are trying to do at all.

17:03 <d_bot> <Icemasta> Sorry. I have to write a program that finds 2 identical objects in an array and return their index position.

17:03 <d_bot> <Icemasta> And we cannot know exactly what it's in the array position (so can't use memory methods), at this point I am sure it's fairly mathematical

17:08 <d_bot> <octachron> If you only have an equal function, there is no shortcut : you need to potentially test every pair.

17:09 <d_bot> <Icemasta> Thanks, that's what I thought

17:22 <d_bot> <Icemasta> Oh I did forget something

17:26 <d_bot> <Icemasta> In the argument of the program we are told how many are false and how many are true. So right now I just thought that since you know how big each group are, I can probably reduce the amount of search to the common dominator. So If I get like 6 false and 2 good, that's 1/4 good, so the maximum distance between 2 points should be 2*4-1, or 7, with something like TFFF FFFT, if I verify in pairs, the worst case is still like brute

17:38 <d_bot> <darrenldl> so each member is either T or F?

17:56 <d_bot> <Icemasta> yes

18:16 <d_bot> <SwissAndOr> In the toplevel, is there a way to separate what your code prints out versus the evaluation that the toplevel prints out?