03:52 mediaim: Me also, I understand that my behaviour is not entirely proper, but it ghosts me every day that estonian terrorists are supported to commit more conspiracy and scams and publicly abuse me without risking any type of legal actions taken against them, like it was a free pass , work wise i've done as much as i could but this isn't enough being surrounded by evil, but work wise i do not have comments that you do it so bad (i just in a need of
03:52 mediaim: extra), which is difference between you and the deepest scammers. And there is none to point out as to what happened to me, it was a very large corruption and conspiracy in favour of abortion leftovers, whose worth never was any and never will be. And unlucky as they never changed their ways, it's constant brainwash to face the tyranny every day continuously.
04:03 mediaim: it has been entirely my understanding , that human beings do not do such things, they must be worms or animals to commit such things, i try to overcome this bad land short so far.
04:22 mediaim: the platform of both intel and amd seems stable, so it is a decent foundation to achieve anything you actually dreamed of. but some people do not have dreams either which distinguishes their evil actions from others too. And maybe indeed such should be blocked or handled by robots or treated.
04:24 mediaim: in theory we have all those extras to the mix, i just have not yet managed to test everything, in my life's fight with the mentioned evil people.
04:35 mediaim: yeah gini also seems perfect once again, elias fano is known to be very efficient, i can provide links, they present the it slightly differently, but it's exactly the same i envisioned as final result, so you have this two sequences of bounds, and it fragments them to low and high bits, and counts the lows to compose final bits of 16 bit or 32bit variable, it is with nearly maximum compression.
04:41 mediaim: but i boot out again, in month or so, i can not work on full barrels yet, but schedule has been done for the end of the year, once i get everything sorted out, but there is no rush, i did a lot of work already, and overseas, i did much work on fpga's too upfront and research and security work
04:41 mediaim: i landed at microdebts, and with not so much troubles i pay them back, but need to do other things
04:41 mediaim: for that month
04:44 mediaim: every bigger institution or country wise or however taken, has those supreme stacks too, there is no rush.
04:50 mediaim: i give my everything after that month to test and bring some base stack for the whole distribution but it's a long journey to test such distro, it demands every day work for half a year in a row or even more, timely wise i need support from others again.
04:55 mediaim: idea is to force the time domain, simplicity, compression, all the performance through the containers system wide
04:57 mediaim: and in the process get hose binary container blobs to function on every vintage hw too
04:58 mediaim: we might target such a precompiler now yes, i did enough monitoring of the relevant trees, they might have some known bugs which in the process need to be removed.
04:59 mediaim: i moved to linux and am happy with it, but the system containers and mono can offer windows to be programmed on, i account for osx too, but i use linux my own, and do not appear to switch off from it as of yet.
05:00 mediaim: i use mint and mxlinux but any distro could suite to me, whichever currently installs without trouble
05:00 mediaim: linuxmint just never installed on macbook, that is why i switched to another.
05:08 mediaim: i've been backed up so far, by pretty programmers, the ideas i have been presented, have gotten immediate attention and good work and research done at, so we will succeed likely.
05:13 mediaim: and airlied someone had apologised alike about being bit intrusive of obsessive too much to bother others, so i know i am guilty of it partly, however whatever for the sake of future, my understanding about mmio blocking is that you encode an event loop in compressed format on cpu, and poll the mmio grand totally at cpu perfect event loop instead , that is very fast on cpu once you propagate the alus, and yeah that is the real way, so dma
05:13 mediaim: deals with io , that could work as workaround.
05:16 mediaim: it would not stall then, but the issue is that even loop could grow into a large case that just makes too high latencies, that is why it needs a modern data structures instead
05:20 mediaim: it's in the r500 documentation an old, how scratch space can poll some event to be accomplished or finished, until the ring goes forward
05:20 mediaim: err, in old r500 docs from X foundation documentation
05:23 mediaim: so one can introduce some gpupoll system call or ioctl on cpu
05:26 mediaim: i think it's mainly known as third party dma , which could poll things through some more complex chain
05:29 mediaim: so that would make so, that always maximum band is taken out...and locks that screw up on slower cpu can all be removed
05:31 mediaim: let's say synchronization primitives, i am not sure what you use there, fences or whatever
05:35 mediaim: i think those are implicit fences, that should be meant to synchronize the cpu model to gpu model combinations of arbitrary, i just imagine that way, there are also fences that end user programmer orders
05:41 mediaim: but i think you were right, the fence should be handled so that yeah the ring pointer could control it, so the cpu waits and polls the indirect ring message
05:41 mediaim: from logs it appears that everyone understood it
05:43 mediaim: and i expect whoever was that guy having this nvidia error on mmio write sync, had a bit slower or faster cpu than intended or tested on or expected
05:47 mediaim: drivers concern is not to distinguish what the packet is, i think it's always some copy package, and poll is always offered hence, though they name it SCRATCH in case of accessing gpu shader registers
05:48 mediaim: but it could be pure memory to memory copy too
05:49 mediaim: gpu dma always works in fifo mode, so radeon just has two different signallers on the indirect ringbuffer
05:49 mediaim: on nvidia i do not know very well
05:50 mediaim: so on radeon it has two dma bursts that can signal things one will launch the other and relaunch the calling one once completed
05:53 mediaim: so for an example if you do not use those syncs, like described, if CPU is too fast, it will drain all the channels
05:53 mediaim: and wants to add something that can not be added
05:54 mediaim: or if it is too slow it's the other way around
05:56 mediaim: workaround is yeah to have aux mmio that even loop always is tied to, and does not allow it to runahead or lag behind
05:58 mediaim: in other words, that would put arb sync on for every write, and yeah that is fast enough
06:00 mediaim: so the view is that cpu controls it's io via dma...
06:00 mediaim: gpu updates to third party dma chipset , and cpu dma gets it from there, and cpu has compressed event loop or new modern arb sync so to speak
06:04 mediaim: so what you eventually do, is lift all the block of driver that is open source anyways, to an event loop, that you compress with elias fano
06:05 mediaim: and ideally you get rid of all errors of such kind
06:15 mediaim: the basic thought comes from Cornell's work, so you have compiled a set of gpio writes in elias fano format, the dma decodes those through using an adder that they exposed, crazy good work, i always missed it, they hit the nail, but ok
06:16 mediaim: so the dma just writes those gpios, and cpu polls, dma decodes those elian fano formats easily with its procedure
06:20 mediaim: cpu can wait on it with arb sync, just and aux memory, it just acknowledges the write, how would it look like i am thinking? they can also switch, once cpu writes, once gpu writes, then cpu then gpu ping pong
06:21 mediaim: this will end up ridiculous fast
06:26 mediaim: to me, just that those mmio writes that do not belong to the even loop, are just no oped, and the ping pong version is not needed, so once cpus dma chipset third parties to gpu dma channel writes
06:27 mediaim: it gets the yes it has an index on the elias fano cpu counterpart, but it does nothing but just reexecute the event loop, in the buffer there is just no-op which is ack
06:28 mediaim: and if there is a need to play sound instead or do some certain gpu context, it is already handled so that sdl event loop would
06:28 mediaim: just execute something that is not nop
06:35 mediaim: as such language we are not aware about where one can define function inside a function, that all means what i call you redefine an event loop, and issue gpio writes through that to begin with until all the stack stabilizes with a year of development
06:38 mediaim: that means the gpio32 definition now has event loop definition which calls the write
06:39 mediaim: so you begin with defining that smaller event loop, cause maybe those glasgow solvers and ginis still hit some bugs etc. some manual intervention is needed
06:42 mediaim: at the moment where there is no raw event loop ABI/API, the radare framework could separate the event polls out for instance
06:43 mediaim: and provide you a definition which to compile and link to the drivers
06:44 mediaim: its the only one i so far have inspected, cause cnf does not distinguish system calls , divine could do that though, and maybe something called runtool for solvers, which i just have not looked into yet
06:49 mediaim: I am not sure if you like LD_PRELOAD
06:52 mediaim: but the solution should not be very complex, wherever that application wise event parsing starts, that needs to close at when it closes, and that is how the event loop gets digged out
06:54 mediaim: i am not sure if that can be obfuscated, but if it can be it can be traced at runtime too
06:56 mediaim: symbolic execution would do it
06:56 mediaim: they can crack passwords too
06:56 mediaim: tutorials also available
07:03 mediaim: i think the even loop is mainly keyboard network and some sound and other gadgets, i am working on how to
07:03 mediaim: get it compressed
07:05 mediaim: reconstruction is that it can have a million sized case tables, and it has a procedure to jump to non-compressed hunks to begin with
07:05 mediaim: so the event loop would become very fast
07:11 mediaim: it should be fast relief, some temporary mixed solution, so the gpio write is lifted and validated as no-op and jumps back the elias fano event loop
07:12 mediaim: whatever the gpio address was, this way it's for sure that cpu acknowledged it and serialized it
07:14 mediaim: where as if something needs to be done, it just jumps to that location that does it
07:26 mediaim: but now need to sleep and go to bank, card i lost, i need at least a weeks time to investigate how can i at all get to event loop case table in binary rewriting, so it would always be deterministic
07:28 mediaim: from there yeah once something gets written it uses the whatever function site of gpio/mmio cpu write which causes it to revalidate jump back to the hashed event loop
07:29 mediaim: it would make some benefits too, runtime gets faster if this case is compressed, and depends how much (how big case) you can compress without bugs
07:31 mediaim: performance boost would be immense anyways, cause this event loop always runs
07:31 mediaim: and consumes a lot of latency, so it right away would be something like 1000fold improvement
07:34 mediaim: but the exact calculation i do not know, the boost is big, cause in terms of overall runtime, event loop always runs and consumes much, i do not know how to do those derivatives of latency calcs
07:34 mediaim: but roughly 10 million times faster event loop
07:35 mediaim: that means something like 1000times improvement under systems alike
09:37 mediaim: that is a bit weird, i did not expect it to have such thing long since available .... https://metacpan.org/pod/AnyEvent
09:37 mediaim: it might be that it can technically hook into hashed events infact
13:34 mediaim: I slept a bit and need to continue later, but I did not consider one thing, that the function of the callback can have a condition variable to set up the return stack, they watch this memory likely. In other words, it could be that event loop is wrapping up compatible.
13:37 mareko: arsenm1: yeah, I have the sqrt change under review
13:42 mediaim: And i think, still one can not enter the callback from this condition, however with such perl code, it should be quite easy to add a triton symbolic execution annotation to the perl code that installs it's own handler, and gathers every location of the event callbacks.
13:53 mediaim: it's hence slightly easier, cause those computers are stack based that i have, to identify the beginning of even loop is something where the handler that gets wrapped up, returns, and to identify the callbacks you put symbolic value, and see where it returns
14:08 mediaim: true event loop is anyway something that calls poll or epoll, so that is really possible then.
14:24 mediaim: yeah makes sense, even interrupts they return with iret and on 386 and+ it would be next instruction
14:26 mediaim: one can just walk the stack and get all the needed and compress the event loop through precompiler.
14:34 mediaim: inlining is not the caveat, do not know about stack randomization, but anyway this can be removed upon request.
14:39 mediaim: calling convention gives it away so those bound checkers, can easily do it, once again i am sorry for the noise :D, i try my best to be quieter.
14:39 mediaim: :=)
21:37 mediaim: I finally understood that event loop can not make a copy of the variable the syscall returns, cause when there are blocking descriptors it hangs the whole program. In that sense event loop has some basic rules. And it looks like there is no need for symbolic execution hence.
22:15 mediaim: so in that sense, it is even likely that one is not allowed to inline the event loop, so they have to have callbacks, otherwise the thing hangs
22:27 mediaim: i could be wrong, i am fresh at this, but you know i think they poll, then read in the predication assembly i dunno header, the condition of global kind, and from there they return, so if the memory was not read finished, the event loop does not bother, it will return to new location where the same thing happens, memory is being read without syscall now and they do not return variable, they just return 0 that everything was ok
22:37 mediaim: so anyway, now that this is cleared out, then can one assume, that during binary execution the offset from where no match clause jumps, is also the same in the on disk container, so it's in 1 to 1 relation
22:38 mediaim: cause sure the 0 cause variable can be initialized in the container, can not match anything, in which case it jumps right to the end , to do something else then back to event loop
22:40 mediaim: i mean they can return whatever they want, but nothing that depends on the memory or have dependency on the memory, cause yeah this would just stall everything
22:43 mediaim: i think it's not relevant, it's best to do it in DBI which is dynamic binary instrumentation, there is no static needed.
22:45 mediaim: i mean whatever the stack randomization does, one can still dump the needed code, and do nothing else, then feed that code to solver to pack things up
23:02 mediaim: i think i am ready in near days how to dump that event loop, even ptrace should be fine
23:04 mediaim: or ltrace and such tools, there are many i look into it, the most advanced i had seen was libdimentio
23:17 mediaim: assembly stuff, i am unsure how AnyEvent does it, but overall, when something gets returned, the calling convention needs to read it so it needs to setup a prologue and epilogue in asm, RAS is in hardware
23:36 mediaim: ok, so that boils down to having compiler insert literal constant i suppose if stack is separate
23:43 mediaim: or a function pointer could suite as well