Re: Threads across programming languages

On 05/04/2024 01:35 PM, Chris M. Thomasson wrote:

On 5/4/2024 10:25 AM, Ross Finlayson wrote:

On 05/04/2024 09:03 AM, Ross Finlayson wrote:

On 05/03/2024 09:34 PM, Chris M. Thomasson wrote:

On 5/3/2024 9:30 PM, Chris M. Thomasson wrote:

On 4/29/2024 9:44 AM, Ross Finlayson wrote:
[...]
>
Have you ever read the following paper? Pretty nice!
>
https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/tr-2001-39.pdf
>
>
>
>
If not, read all...

>
There is a way to do a little sort, gain a cohort and execute it. For
instance all reads, writes, connections, accepts are all organized in a
cohort.
>
Instead of processing a read, write, read, read, write. Say:
>
read, read, read, write, write
>
To get better locality. I remember some functions on winnt. AcceptEx,
ConnectEx, TransmitFile, TransmitPackets, ect... ;^)
>
The main thing to use to wait on io completions:
>
https://learn.microsoft.com/en-us/windows/win32/fileio/getqueuedcompletionstatusex-func
>
>
>
>
https://learn.microsoft.com/en-us/windows/win32/api/mswsock/nf-mswsock-acceptex
>
>
>
>
https://learn.microsoft.com/en-us/windows/win32/api/mswsock/nc-mswsock-lpfn_connectex
>
>
>
>
https://learn.microsoft.com/en-us/windows/win32/api/mswsock/nf-mswsock-transmitfile
>
>
>
>
https://learn.microsoft.com/en-us/windows/win32/api/mswsock/nc-mswsock-lpfn_transmitpackets
>
>
>
>
I used to use them all the time back in the day.

>
How about Hillis' "Connection Machine" and xectors.
>
"Affinity" is the most usual sort of notion of
locality and reference and that things that are
local are simpler to address and keep coherent,
having smaller address offsets.
>
SIMD or single-instruction-multiple-data and
"clubbing cohorts" of routines that have a
common program counter in their next instruction,
seems a pretty simple idea, what with what enables
this is usually "content associative memory",
that routes things into buckets rather naturally.
>
(In silico.)
>
It's like "we'll just use content-associative-memory
and get a huge speed-up" and it's like "oh, what
if it's otherwise occupied". It's like "oh we'll
just add burst-buffers everywhere between units of
the traces on our dies to modulate rate control"
and it's like "there's no room on the layout".
>
Then it's like "the chips made this and we wrote
a scheduler and now it's according to us" and
it's like "yeah, in a sense, it's system programming".
>
>
Which of course is quite "old hat" and all has "prior art".
>
>

>
>
It reminds me of this time about fifteen years ago,
I was at my desk and the phone rang. I answered
the phone to "This is monitoring. Are you running
a script?" And I say "Yeah, I'm running a script on
monitoring." And they say "It's degrading prod."
I say "Do you want me to stop it?" And they say "Yes."
So, I hit Ctrl-C in that terminal as I'd designed my script
to populate all the monitors and alerts and alarms for
all the metrics of all the APIs and granular to the client
and with rollups and suppressions to distinguish outages
from use-cases, across all services across all regions,
to not much care. Then I added a brief pause between
calls and re-launched it.
>
Sometimes using all the resources isn't very fair.
>
>

>
Think of a client that would try to make the server use all of its
resources and actually get into a major danger zone, even flag a malloc
returning zero. Then there is non-paged memory to consider. On windows,
each in flight OVERLAPPED operation uses non-paged memory... If that
goes down, well, its not good at all... ;^o

The robots.txt file is a convention
usually indicating the host's preferences
that they'd rather not have robot crawl
their entire site.
Or, you know, "spider".
"A large number of problems
require the optimization of multiple criteria.
These criteria are often non-commensurable
and sometimes conflicting in nature
making the task of optimization more difficult.
In such problems, the task of creating
a combined optimization function is often not easy.
Moreover, the decision procedure can be affected,
by the sensitivity, of the solution space, and the
trade-off is often non-linear. In real life we traditionally
handle such problems by suggesting not one, but several
non-domainted solutions. Finding a set of non-dominated
solutions is also useful in multistaged optimization problems,
where the solution of one stage of optimization
is passed on to the next stage. One classic example
is that of circuit design, where high-level synthesis,
logic synthesis and layout synthesis comprise important
stages of optimization of the circuit. Passing a set of
non-dominated partial solutions from one stage to the next
typically ensures better global optimization."
- Dasgupta, Chakrabarti, and DeSarkar, "Multiobjective Heuristic
Search", 1999
What that says is that if you put two greedy fish in
a tank, the result is one or zero greedy fish.
About something like a usual milieu
of remote procedure calls as HTTP,
one figures that each HTTP API should
have a "ping" method, to determine availability
and expected duration of outages,
and a "rates" method, to declare
what are expected serviceability of rates,
and what are costs.
For something like HTTP, one might imagine
that as a simple convention of headers in HEAD,
or OPTIONS, for the various other HTTP methods,
their "ping", "rates", and "costs".
https://github.com/ietf-wg-httpapi/ratelimit-headers
It's not un-natural to be greedy,
yet common goals of co-operation
are usually advised as for good outcomes.
Robots