Hello, here I'll post some design notes and a panel discussion with some chat-bots about making some sense of the "vector-wide scalar word"
and "character machines", on commodity hardware about ubiquitous
operations.
It's considered at least tangentially relevant to comp.lang.c and comp.lang.c++ because for example text is ubiquitous and the targets
would be low-level, while the higher-level languages would have a
same sort of patternry, and for example that libc and cstdlib are
standard, and as with regards to POSIX and Unicode and so on.
Please feel free to excuse or ignore, or comment as freely.
Thanks for reading.
On 07/27/2026 11:43 AM, Ross Finlayson wrote:
Hello, here I'll post some design notes and a panel discussion with some
chat-bots about making some sense of the "vector-wide scalar word"
and "character machines", on commodity hardware about ubiquitous
operations.
It's considered at least tangentially relevant to comp.lang.c and
comp.lang.c++ because for example text is ubiquitous and the targets
would be low-level, while the higher-level languages would have a
same sort of patternry, and for example that libc and cstdlib are
standard, and as with regards to POSIX and Unicode and so on.
Please feel free to excuse or ignore, or comment as freely.
Thanks for reading.
[ viswath-charmaigne.txt ]
Widesword: SIMD/SWAR patterns/primitives
For parsing and binary data, patterns of algorithms and their
primitive functions upon arrays of items and about bit-fields
of their contents.
text
sets (Unicode, ...)
encodings (ASCII, UTF-8, ...)
classes (Latin1, ...)
glyph-maps
binary
structured
compression
encryption
parsing/scanning
blocks/sections
nesting/indentations
brackets/groupings
commas/joinings
predicates
predicates for parsers and scanners to compute and collect for items
SIMD/SWAR
emulated/specialized
Widesword or "wide-word", the "vari-parallel"
The usual architecture makes for interrupts and DMA,
and then the super-scalar the vector architectures. The
idea is that the fundamental interface should be in terms
of the super-scalar, with the scalar as a limited case.
access/mutate
load/store
gather/scatter
move/move
pack/unpack
match
exists
find
find-first
find-all
apply
translate/decode
Mostly about arithmetizations and algebraizations, is to figure out what instructions are branchless to result the carriage, then combinatorially enumerate those, and those are thusly their own sorts "normal forms"
for arithmetic machines or automata, then to compose those.
The accessors and mutators reflect upon that the data is in memory,
while the processing is on registers, access-patternry is "load" from
memory, and mutate-patterny is "store" to memory.
stripe <- contiguous
stride <- modular
striqe <- patternry, aperiodic
stribe <- patternry, periodic
For matters of alignment, there are these sorts native alignments and
sizes.
PAGE_SIZE page size, usually 4KiB, operating-system
LINE_SIZE cache-line size, usually 512 bits / 64 bytes, chip
SWORD_SIZE scalar-word size, usually "64 bits", 8 bytes, on 64-bit chips VWORD_SIZE vector-word size, eg 128, 256, 512 bits (16, 32, 64 bytes)
Then, the processor has a given assortment of scalar and vector registers, and various accounts of addressing the low and high portions of those
on the scalar registers and as they've been extended, and about the
vector operations on the vector registers.
The accounts of alignment and protection then get involved, about
the access-patternry, and the offsets, and alignment of the data to
words, or the pre-amble and post-amble or entry and exit of loops,
that the usual account of "apply" or "find" or "match", is as like a
loop, then as with regards to vectorization, then as well concurrency,
and the incremental and side-effects, then to define algorithms (functions) as by those.
The vector registers are in banks of 8 or 16, then there are sometimes multiple banks of vector registers, for example the Intel "MMX" vis-a-vis "AVX512".
Algorithms will basically have inputs, constants and lookups,
and outputs, designations of the vector registers.
The modeling of higher level code to the operations upon the
registers is as of mathematical models.
algebraization <- relating to algebras/magmas generally
arithmetization <- relating to arithmetic
geometrization <- relating to geometry, for example a grid lattice
Then the relation of higher-level code to these models is
according to acts of "expression" and "interpretation".
Items, Predicates, and Indicators
A usual idea for "find" is to evaluate predicates (true/false functions)
on items, to result indicators, then to "find-first-set" or "find-first-clear"
for "find-first" return a found offset, and to return a count and array of found offsets for "find-all".
The "wide-internal" and "wide-external" reflect whether predicates
are within the representation on the registers, i.e., "register-internal"
and "register-external", about whether function calls (external) are
involved to evaluate predicates. A "function" as internal results
the evaluation of the predicate as indicators on a register.
When loading items, for example characters as bytes or in a character encoding like Unicode or UTF-8, then a usual idea is to load a register,
then for the branchless computation of the offsets of the items,
when for example UTF-8 codes have variable length, then the evaluation
of predicates on those, whether for example a null-termination of a usual
C string is to be computing strlen, to find the offset, and compute the length.
Code Sequences and Scanning
The textual and character data or otherwise codes of fixed or variable
width make for the idea of character set designation or detection,
then the scanning or searching of character data, where Unicode
is ubiquitous while historical codepages are extant, then for usually
enough either UTF-8 generally or ASCII as Unicode's Latin1 Basic
Multilingual
Plane, with Microsoft's CP-1252 changing out a handful of characters
from that,
then with regards to various organizations of UCS-2 or BE and LE and with regards to byte order marker BOM, then to make for usually enough the automatic assignment of character classes and implementing regular expressions
and grammar productions along items, predicates, indicators, as tabulated
at compile-time in tables of constants derived from the specifications.
The binary codes are not dissimilar, with regards to encoding and decoding
or compression and decompression or encryption and decryption,
about the "vari-parallel" in codes.
Commodity Architectures
The two primary targets are Intel/AMD and ARM. They each have various
counts of scalar registers, then various considerations of vector
registers.
Intel/AMD
MMX/SSE (Pentium)
SSE2
SSE3/SSE4
AVX/AVX2
AVX512
AVX10
ARM
NEO
SVE
The SVE ("scale-able vector extensions") notably doesn't have a fixed
word width of the vector registers.
Then, the targets would be
SSE4 + SSE3 + SSE2 + SSE/MMX: SSE2 + SSE4.2
NEO (ARM)
AVX/AVX2
AVX512/AVX10
SVE (ARM)
or profiles into
SSE2
SSE4.2
AVX2
AVX512
then with regards to ARM vis-a-vis Intel/AMD what profiles match.
The target here is mostly (or entirely) integer operations not floating-point,
while both the vertical and horizontal operations get involved.
Calling Conventions and Wide-External
About register allocation and for something like "register coloring
normal forms",
there are basically cases where registers are to be preserved and when
they are
scratch. The idea is that as scope accumulates, that registers are to
be preserved,
so that basically according to scope depth and stack accumulation,
various accounts
of the registers, for example according to an accumulating mask, get preserved,
i.e. pushed to the stack then popped off the stack, or context-restored,
with the
idea then to make it for the compiler for sub-routines, to compile to a reduced set
of registers, toward establishing what are "scoped" and what are "scratch", and about the allocation of registers in the hard-code both vertically
and horizontally,
adding a new dimension to otherwise usual accounts of graph coloring,
instead to
make an account in the calling conventions.
Then, the usual idea of passing arguments from the higher-level language as parameters in registers is that they are scratch ("volatile").
scoped (required preserved)
scratch (dont-care)
volatile
nonvolatile
caller-saved
callee-saved
https://en.wikipedia.org/wiki/X86_calling_conventions https://en.wikipedia.org/wiki/Calling_convention#ARM_(A64)
Then the idea is that wide-internal routines are entirely compiled as
blocks
and have zero-overhead abstraction, while wide-external routines get described
the conventions of how item-predicate-indicators are organized in terms of the histograms and input-output.
Capabilities and Initialization
The processors have a common instruction "cpuid" to query capabilities
and profiles of the vector instructions in the instruction sets. Then initialization is system-wide, while yet various accounts of the statically-linked
or libraries would make for initialization of the routines before their organization
and layout.
It's figured that the blocks of routine would be combinatorially enumerated into making a single binary for a given architecture, then that initialization
would set the entry points into the widest routine.
So, besides linking would be involved for this sort "wide binary"
(vis-a-vis,
"fat binary"), then also for the statically-linked, that initialization
would
set the offsets and install the offsets (if not, "self-modifying code",
with
regards to code segment protections),
Stack Machines and State Machines
Implementing text algorithms then finite formal automata and state
machines,
is for making an account of how to employ the wide-words for the vari-parallel
to implement state machines for scanning and parsing and the evaluation of regular expressions.
Elementary and Novel Vectorization Approaches
Considering the vectorization of general purpose computing,
then there's an idea that the elementary are what building blocks
are possible, then that the novel is to make algorithms on the
vectors that would be inefficient in the scalar, particularly about
the branchless and non-stalling, about what can result in effect
are machines or models of computing, according to SIMD/SIMT,
given that then the elementary machines are composable.
The basic idea is to implement "stack machines" and "state machines", according to various organizations of what makes for finite automata,
and models of computing, then to make the arithmetization of those
according to states and transitions, then that an upper bound of
computing is determined that guarantees arriving at a solution,
then that's un-rolled and figured to run in-place towards the
"branch-less" and "stall-less".
The basic idea is that stack-machines are implemented in integers,
then about using prime rings to indicate transitions, then that
the finite-state-machines are built out with multiple equivalent states, vis-a-vis unique states, then that the arithmetic carries through either
way equivalently, or for pushdown-automata and finite-state-machines,
here "stack machines" and "state machines".
Bit-Sets and Prime-Multisets
The bit-set is a most usual notion of the arithmetization of a set,
by a dictionary of codes to offsets, an indicator bit indicates membership
in a set of a code, where the bit-set has a maximum size the word-width.
The prime-multiset is after a dictionary of codes to primes, then the divisibility test indicates membership, and multiplicity indicates count
in the multi-set. The prime-multiset has size varying according to word-width
(unsigned integers their range) and that more common codes get assigned smaller primes and more rare codes get assigned larger primes, as much
like the Huffman coding.
In vectorization and bit-methods, accounts of the like of "Digit Summation Congruence" make for divisibility tests in binary for a subset of the
primes
that are tractable to Digit Summation Congruence, then that trial division follows for multiplicity of factors (count in the multi-set).
Parameterized Dimensions and Instruction Classes
The instructions are as of the instructions and their prefixes and
their operands in the instruction sets and the assembly languages,
then that they fall into classes of equivalent behavior, and according
to dimensions as so parameterize their sizes.
Ttastm/ttasl Mnemonics
After the parameterized dimensions and instruction classes,
are these sorts mnemonics and syntax.
mov, push/pop, load-effective-address:
lod < (dst, src)
cpy = (dst, src)
sto > (src, dst)
adr @ (load-effective-address)
psh ^>
pop ^<
It's figured that "copy" (assignment), is a reg/reg or reg/imm operation, while then the above are the only reg/mem, mem/reg, operations.
arithmetic:
binary (with target destination):
and &
ior |
xor ^
add +
sub -
mul *
div /
unary (and in-place):
inv ~ (unsigned)
neg ~ (signed)
rev <>
inc ++
dec --
ror }}
rol {{
shr >>
shl <<
Unary operation act in-place on a register the destination,
binary (or dyadic) operators vary on whether the destination
is one of the operands (for example running-sums on x86) or
a separate operand (multiplication and division on x86 and
arithmetic usually on ARM).
So, the usual idea is that each usual instruction has a three-letter mnemonic,
and a given syntactic construct, then the arrows (angle-brackets) indicate directionality, for usual constructs:
b < [location] # stores location's value in b
a = b # assigns a to b.
a > [location] # stores a in location
It's figured that thusly "mov" is distinguished between memory-moves and register-moves,
binary:
a = b + c
unary:
a++
a--
a << 3
a }} 3
The '#' is used to indicate comment to end-of-line,
then also ';' can be for comments.
Un-used characters include:
!
$
(
)
[
]
_
:
,
.
Further usual operations have mnemonics yet not syntax symbols,
then for a usual idea of defining or overriding symbols.
bsf (bit-scan forward/reverse, find-first-set)
bsr
ffs
ffc
btt (bit-test/bit-test-complement/bit-test-reset/bit-test-set)
btc
btr
btr
bts
cnt (population count, set bit count)
pushall
popall
byteswap
spread (reorganize: widen registers)
shrink (reorganize: narrow registers)
Declarations of types with data-type and data-size,
have that the default type is unsigned int,
then that the default size is the scalar word width.
quar
half
doub
quad
siz
len
swap
shuffle
pack
unpack
sum
prd
Targets:
State Machines / Automata
Character-Set Conversions
Regular Expression Matchers
Huffman coding
Deflate algorithm
Parser/Scanners
State machines as "plants" and "arcs" for "states" and "transitions":
always starting or continuing an "arc".
The "offtables and "noptables" that have that "noptables" make
for the deductive elimination, while the "offtables" have the
inductive carry.
Then the usual idea of the parallel is that each sequence of possible
arcs is a long-ish table, that point to a list of inferred plants,
and the next arc.
The "arc" for the scalar, for the vector, and for vector-lookup.
byte
scalar
vector
vector-lookup
Correctness, Diagnosibility, and Performance
Modes
States and Transitions
Arcs and Plants
codes in -> symbols out
Decoder vis-a-vis Encoder
windows
duplicate detection / histogram
off-tables and nop-tables
rejecter/accepter
Then, the idea is that a usual function call gets the input on the
registers, with a
usual signature like so:
ret_t f(
const char* input,
unsigned int input_length,
const char* output,
unsigned int output_length
);
then that the idea is that a stride over the input is for the vector register, loaded
as an unsigned integer, then to make for the bit-wise or byte-wise
processing of
the input and generation of the output.
The input is variously fixed-length or variable-length, bit-wise or byte-wise, with
the byte being the least addressable unit of memory byte-offset and the
bit being a fungible
value bit-offset, the registers being here considered the integer values
and of the un-interpreted
bit-sequences vis-a-vis their sequences as uninterpreted byte-sequences, which in
the C library is according to the constant CHAR_BIT which is almost universally 8
(bits per byte).
The half-byte then is called the nybble, two-bytes is called a short, four-bytes is
called an int, and 8-bytes called a long, or for short/int/long as
16/32/64 bits.
Then, the vector units implement an instruction called shuffle, which
makes a
lookup: it looks up nybbles for nybbles (vector-wide, in one
instruction, from
the codes and what results offsets in the off-table or jmp-table).
So, for each of the four bytes in the 32-bit word, the idea is that each
of the
possible combinations get a mapping, then the off-table is consulted after the shuffle lookup, and then 0-4 tokens are recognized, else extending
the bounds
of the token.
The idea is to make the lookup-table index/offset, that is generated/compiled,
that given the codes, results the symbols.
So, the idea is that a few different shuffling constants produce the
nybbles
for each byte, that are zero for a usual missing case, and get composed to make a tree-traversal, among the possible next states of the parser or
the arc,
within the limits of the nybbles, then that if it works out beyond the
limits of
the nybbles, to start afresh within the register word, within the limits of the nybbles their range of codes, making for bytes or characters, how they continue the arcs and make the plants.
0001 0001 -> continue, most likely mode
0100
0101
0111 -> second most likely mode
1000
1001
1011 -> third most likely mode
Thus, using a prefix-property of the nybbles, makes it possible for up to three codes/characters, their second and third most likely modes, or arcs, while when there are predictable modes, or arcs, then there is a continuing arc or up to four plants (output symbols, tokens).
Since the nybbles are in pairs to make a byte: is for that to determine
the
upper and lower making a compatible code, is the contingency of the
high nybble and low nybble, what results an unambiguous byte.
This is for making permutations and then rotating through them until
it's invariant, making a check that the two nybbles agree on the byte.
So, for reducing the alphabet size, is about fitting the alphabet into
less bits.
2^5: 32-many, [a-z] + 6
2^6: 64-many, [A-Za-z] + 12
Then, building codes can work in the lowercase, in the case-insensitive,
then the idea is that usually a character is a char or a byte,
yet, it's two nybbles, so, all the productions of the grammar,
start reducing to those, then, as well, for UTF-8 and so on, that's a
higher production, and then for fixed-width Unicode and so on,
also as like a higher production.
Shake-Sort
The idea for shake-sort is to use horizontal compare to simply
enough by making transpositions, then computing the masks
of blends/shuffles, and resulting then that a word its segments
gets sorted, then for sorting words, to interleave them then
apply the un-rolled shake-sort, which will shake out the order,
in a branchless and arithmetic way.
Huffman Tables and Huffman Coding
The idea is to automatically make a population histogram,
of the vari-parallel or varallel, then to make alphabets of
that to get related the coding, so then the codes are small
and can be put through a dictionary to result making the
matching and the scanning of the symbols from the codes.
Character Classes
digit
alpha
punct
space
digit:
arabic
hex
alpha:
upper
lower
punct:
comma
colon
semicolon
ampersand
unscore
vpipe
bslash
slash
period
qmark
xmark
paren
bracket
curly
angle
quote:
single
double
curly
arith:
add
sub
mul
div
mod
asterisk
tilde
unicode:
block: https://www.unicode.org/Public/UCD/latest/ucd/Blocks.txt
So, the idea is to make the "available and significant indicators", that thusly result predicates organized in bits, then to make that a usual
first account of scanning, is to make a lookup for the printable ASCII,
then to go about the notions of the composable grammars.
0001b white
0010b punct
0100b alnum
1000b other
Then, "other" begins to include both un-printable control characters,
and, basically everything above 7-bit ASCII.
Then, these classes are usually exclusive, then about cases among
them when they cross.
punct
inner
outer
affix
For example comma is inner, brackets are outer, and hash-tag is
an affix, yet in usual accounts, period is both an inner (when used
as "dot"), and an affix (when used as "stop"),
white
vert
nl
cr
vt
horz
space
tab
alnum
alpha
digit
So, the first nybble is as above, then the second nybble is to work
into those.
white:
0001b vert
0010b horz
0100b ligature
1000b other
vert:
0001b nl
0010b cr
0100b vt
horz:
0001b sp
0010b tb
Then, it looks that the constants table for ASCII is at least three
nybbles,
then to make for various ways then that when loading a register of
character data, is to be making that then the scatter/gather makes to
gather the constants from the table, 16-bits for each 8-bits, for example into two registers.
r1: char-data
r2: preds-1
r3: preds-2
Another notion is to have that white-space is simplified
white:
0001b sp
0010b tb
0100b nl
1000b cr
then that 0000b is "other".
The main idea is that there are various uses of text.
source (and data)
spoken (natural language)
Then, the various predications, are to reflect positive predications
of closed classes. Then, 0000b is reserved for non-predicated (un-closed).
0001b punct
0010b alnum
0100b white
1000b coded
Then the idea is that bytes with the high-bit set are UTF-8 encoded,
and that control characters are also "coded".
256 characters
loading onto a register
scalar
access item-wise
vectorized without scatter/gather
vectorized with scatter/gather
Then it seems that the gather instruction in x86 starts with AVX2
about floating point values, though that it could just load the
values as literals and then treat the registers as being integers.
Then, for four of those being in a register, the idea is to load up
the entries from the table, then merge/broadcast those together,
to make the bytes/shorts with the flags into the registers.
op set:8:32(index)
op clear:8:32(index)
op place:8:32(index)
32 = 8 << (#8 * index)
op pick:8:32(index)
8 = 32 >> (#8 * index && 0xFF)
The suggestion here is that 32 and 8 are built-in types,
and number literals are prefixed with #. Then, these
would be specialized like templates for each of the types.
op gather:8(indices, table): output
output[0..7] = load(indices[0..7])
The idea here is that there's a range notation, that only
8, 16, 32, 64 are "types", and other numbers are offsets
or with ".." making "ranges", then that to result an un-rolled
loop.
Ranges range with the values, using .. to indicate connecting
the start and end increments inclusive, and comma to indicate
particular values, then for example named classes like 'even'
and 'odd'.
[0..3] # 0, 1, 2, 3
[1,3] # 1, 3
[even] # 0, 2, 4, ....
[odd] # 1, 3, 5, ....
The syntax construct with brackets (square-brackets) in
C-language is usually enough an array "dereference", the value in the
array at the offset, while in A-language is usually a dereference under
the pointer, then here in "TT-language" the idea is that it is like the mathematical interval, inclusive.
The index and offset are about variously the bit-wise and byte-wise,
about the ordinal offset of the bits, and, the ratios and fractions of
the bytes, in the bit-sequences the words.
Then, a usual notion is to nest the intervals, that byte-offsets
are indicated in ranges by [], and bit-offsets by [[]].
[3] # byte 3
[3[1]] # byte 3, bit 1
The bits are generally considered msb-to-lsb, most-significant-bit
to least-significant-bit, also the numbering, about bit and byte endianness and MSB-to-LSB like network order and msb-to-lsb bit order. Since architectures
may be little-endian or LSB-to-MSB, gets involved that the logical (or, "abstracted")
addressing is big-endian.
The the operations as accept ranges basically have indicated that
these would be as of loops of fixed size, then fully un-rolled, or,
the relevant vectorized instructions, one instruction.
o lay v8 > v32
v32 = v32 | 0xFF
o clear v8 > v32(i4)
o set v8 > v32 ([32/8])
v32 =
o place v8 > v32 ([0..3])
v32 |
Here the point is to indicate that when placing a value into
a register, that if it's already initialized to zero, then it's simplified
to OR in a value, else about indicating that the result is to clear
the byte, then place the byte.
fill
flush
pick
place
Here these would be logical operations, with the idea that
they're eliminable according to the context and the concrete,
or the physical operations.
Then, with regards to the register allocation, is the idea to
indicate for the operations o what are the
scope
scratch
saved
logically, then physically aside.
o fill vN cN
vN: generic vX for width N
cN: byte-count
iN: byte-index
o fill # within a vector, fill a byte or range of bytes with all 1-bits
o flush # within a vector, clear a byte or range of bytes with all 0-bits
o pick # from a vector, pick a byte or range of bytes
o place # within a vector, place a byte or range of bytes
For the register allocation, there's according to the architecture and
the operations, about the dyadic functions (binary functions, two inputs
one output logically) what happens to the operands their value from the
place when the instruction is invoked afterward, whether the operation
is "destructive" or "non-destructive" to the operands, and whether the operation is thusly need "saves" of the values, if they need be "saved".
o add()
o accrue() # accumulate a sum,
o sub()
o decrual()
o add()
Then, since operations are small, yet various specializations of them
as templates will make use of various registers and have varying
numbers of instructions in the resulting assembler, is about that
then the register-plan will have that like "lanes" in the vectors for
data, are "tracks" for the registers, about a usual idea that data that
is re-used is kept on a track, and for example saved on the stack or on
heap,
while then registers that are scratch are rotated to basically exercise the registers in rotation, thusly that the processor will as likely find no dependencies
or hazards, in rotating the fresh registers.
o keep() # either make a track, or save, the contents of the registers
It's figured that all the sources are compiled together, then there
not being any scoping, while within the operations, all the variables
are local, so there's automatic scoping, then though to indicate in
the signature what registers are tracked, thus preserved, so that
the caller can make assignments of it, on it.
v32 a = 1
a = a + a
o add("+"):
v32 lhs
v32 rhs
instruction add lhs, rhs
Here the idea is that the "instruction" keyword is like the "command" keyword, indicating that it's the literal instruction in the resulting assembler.
The operator overload is indicated in the "signature".
v32 a = 1
a = add a a
v32 a = 1
a = a + a
o add (v lhs, v rhs, v ret)
o "+" add
o add (v32, v32, v ret):
# 32-bit values, registers, overflow, ....
instruction add
o add (v64, v64, v ret):
instruction add
Then, it's figured for values v as unsigned, then perhaps for unsigned u.
As well it'll conflict less with "v" for vector.
u32 n = 1 # unsigned, default
s32 z = 1 # signed
f32 x = 1.0 # float
u32 a = 1
a = a + a
o "+" add(lhs, rhs -> ret)
o add(u32 lhs, u32 rhs -> u32 ret)
instruction add lhs, rhs
ret = lhs
o add(s32 lhs, s32 rhs -> s32 ret)
o add<u32>
o add(f32 lhs, f32 rhs, f32 ret)
instruction fadd lhs, rhs
ret = lhs
Then, to infer what implementation gets inline then to be generating
an assembly listing, works backward from the assignment of the return
value, and forward from assignment of the input operands / parameters.
exclamation
composition
transliteration
There is a general notion of writing and re-writing rules.
fill-in-the-blank
connect-the-dots
What's figured is to make for matchers to result then that
enumerate possible combinations
eliminate impossible combinations
with the idea then that there's a very free composition,
with that what's like matches then what's unlike deletes,
for then what results of the exclamations their composition,
to be transliterated, then for file-system organization,
and as of structures.
Spontaneous Compiler
There's much to be made of "simple data files" then
for what make for structure and schema, about the block
and stream of text, and about the dictionaries and the
symbols, as to what's to make result from templates: forms.
"For Viswath and Charmaigne"
The idea for text predicates is that there are the two basic
modes: "source" and "spoken".
Then, for the source mode, there is an array of bytes matching
each byte of a character or partial character.
These matching bytes are pairs of nybbles, primary/secondary.
1a: punct white alnum coded
1b: according to class
2a: interpretation primary
2b: interpretation alternate
Then, the most usual and common sorts of character classes
for regex and EBNF have quite regular forms.
[A-Z]: alnum/alpha upper/
[a-z]: alnum/alpha lower/
[1-9]: alnum/digit whole/
[0]: alnum/digit zero/
space: white/horz pad/space
tab \t: white/horz pad/tab
nl \n: white/vert line/nl
cr \r: white/vert line/cr
bell \b: coded/ctrl
It's figured that these are _exclusive_ classes, then about
when there is the overlapping or _inclusive_ classes, about
for example "is_ascii", "is_graphical" and so on, or POSIX
character classes, it's figured that would be into the
"POSIX character classes predicates".
Then, according to whether the character set encoding is
Unicode with UTF-8, then the primary predicate will be
that it is according to the character set "cset", while
then the secondary will be for the detected or specified
character set.
UTF-8 byte 1 length 2: coded/cset utf8/len2
UTF-8 byte 1 length 3: coded/cset utf8/len3
UTF-8 byte 1 length 4: coded/cset utf8/len4
UTF-8 bytes 2-4: coded/cset utf8/body
Then, it's figured that every character in any relevant character
set has a specific relevant character in Unicode, while, it's generally
so that all "source" texts may be ASCII-only, where that Unicode representations are as of literals and the like.
The puncutation "punct" then gets broken out variously, about
that various modes will either have predicates about the left
and right of the joiners and groupers.
Then, about _commas_ or _joiners_, and _parens_ or groupers,
and _affixes_ or markers, then is that source generally applies
these usually, then as with regards to differences between
arithmetic (eg, l.t. as left angle bracket, g.t. as right angle bracket),
and as with regards to where arithmetic operators are joiners
or affixes, for example negation.
In the alphanumeric, then for numeric literals, is another example
of where the syntax for floating point numbers involves the exponent
and base and radix or significand and mantissa, and +/-, and so on.
Similarly the literals for numbers may include alphabetical flags,
prefixes, and segment separators, for example _ in source text
and commas/stops according to locale in "spoken" (natural) text.
Then, it's figured that in the implementation of parsers or matchers,
or tokenizers or scanners, then the relevant predicates for the classes
have various canonical forms, then specific relevant forms, of the
predicates so pre-computed, so that as a registers of characters is
loaded (C-many bytes), then a gather lookup results that populates
a register of the same-length with the relevant predicates, then
that matching of the patterns according to matching of the bits,
can result from bit-masks and generally about the infrastructure
of determining the bounds of productions, and what among other
productions are relevant.
Here it's figured that the vector registers will be employed as the
constant and the lookup, then that the built
"abstract syntax tree"
"abstract syntax sequence"
"abstract syntax graph"
is working off of the general registers.
A most usual idea is "greedy matching" after Kleene star and Kleene plus
or the Kleene notation for formal languages, then about that the
algorithm gets involved about computing bit-masks matching the
predicates, then ranges of those, to result computing the offsets
of a next match, or when there's the likely and less-likely and un-likely,
in the likely, to find the bounds of multiple matches in the register.
For example, when greedy-matching, starting at an offset, one might
simply AND together successive bits, non-branching, then the first set
bit and the first clear bit after that are at the bounds.
find-first-toggle-bit(off_t from)
Then, besides usual accounts of greedy matching, get involved in
parsing, the accounts of comments, quoting, and escapes.
The escape is used within the text to indicate characters of values
of literals or entities, most usually in source text the back-slash.
The idea then when parsing the like of quoted-CSV or JSON, that
all the strings are in pairs of double-quotes, then that quotes within
the strings are preceded by a backslash to indicate a literal double-quote within the string.
Then, when there are escapes in the language, the idea is that it's a different sort of match, since it changes the punctuation character
to a word character.
So, the idea in this case is to detect escapes in parallel across the word, finding any escape character, then in that production mode changing
those to "coded/escape" of what are the gather predicates, then that
the algorithm can proceed finding the bounds of the productions in
the grammar, then later the semantic reading of the text, can re-interpret those as from the literals again.
About loading the predicates, is the idea that there's a 256-entry lookup table for the 2^8 possible bit-sequences in a byte, or for example, a
lookup
table with 2^16 entries or 64KiB, then to gather those two at a time, where
a 2^32 table or 4GiB would generally be considered too large, yet that as
a facility that 64KiB tables of source/spoken predicates are small and
fit in
the cache, about whether parallel-gather or cache-coherency is improved.
About the likely/less-likely/un-likely, is to reflect that these could
be any
sorts of modes and alternatives and the rest, then that fitting into those few categories makes for that the matching can be very greatly improved, where for example pshufb will make lookups of nybbles, then that the "un-likely" basically starts with the matching among alternative
productions.
Combinations of predicates like accepter/rejecter and intersection/union, then get into how to compile predicates and represent them as computed byte-sequences, then that the machinery of predicate matching, finds
the bounds and emits the bounds and matched term.
So, it's a usual account of building "abstract syntax sequences", or where the productions butt together, starts with disambiguating the "coded" predications, then for example to handle UTF 8/16/32 or variable-length codes, overall oriented toward bytes, then with the idea that the
predicates
are to be computed into the case-specific bits the lookup tables and case-specific
bits the productions, then the machine always works the same way, in a multi-pass sort of approach, or in the "lifting" of the layers of the abstract
syntax sequences, which are nested bounds of the contents the literals
of the productions.
Then "abstract syntax trees" or "abstract syntax graphs" can be built from that, with the usual notions of comments and quoting, and where the
locators point to the original text with its original offsets, from the abstract syntax sequence the source text itself.
https://en.wikipedia.org/wiki/Affix_grammar https://en.wikipedia.org/wiki/Extended_affix_grammar
Detecting and Decoding the Text
So, it's figured that the source text is in its natural layout.
ASCII
ISO8859-15 / CP-1252
UTF-8
ASCII and ISO8859 are fixed-length one-byte, to represent
0-127 and 0-255 respectively, UTF-8 is variable-length 1-4-byte,
to represent all the characters in Unicode.
The above are the most common encodings of source text.
Then, the "detecting" the text would most often have that
be a fixed parameter to the algorithm, since "sniffing" and
the like then would get involved.
UCS-2 (BE)
UCS-2 (LE)
The usual fixed-length two-byte encoding of Unicode
as from "wide character" then may have the "Byte Order Marker BOM",
or "thorn y-diaresis", as an example of a "comment" character.
Then, detecting and decoding starts with the coded/ctrl and
coded/utf8 characters, as would be common to all algorithms,
then gets into "quoting" and "comments", and "invalidation"
and "well-formedness", which vary on syntax.
Starting thusly with the source text, then the idea is that
the higher Unicode codepoints in UTF-8 are "immediate
productions", then that their contributions to character
classes are considered, when for example POSIX character
classes include some Unicode in their definitions of whitespace
or about punctuation, yet that mostly there are never found
source languages where non-ASCII is in the keywords or the syntax.
Then "invalidation" and "nonwellformedness" are to make for that
the "wellformed" is according to the data format, and the
"invalidation" is according to schema or otherwise rules.
These are negative conditions, meaning that a document
is never "validated" nor "well-formed", just not "invalidated"
and not "nonwellformed".
Then, un Unicode, there are properties of characters, these
then relate to the basic properties the initial categorization
of characters.
https://en.wikipedia.org/wiki/Unicode_character_property
So, this sort of plan starts looking like code like this, for example
for the 16-bit or 2-byte case, in SWAR.
mov ax, [input + offset]
xor ah, al # bswap
xor al, ah
xor ah, al
mov bh, [table_source_primary + ah + 0]
mov bl, [table_source_primary + al + 1 ]
# ...
mov [ptr_offset], offset + 2
Then, the input bytes are on register 'ax' after byte-swapping from
the little-endian representation of a 16-bit integer as was loaded,
and the relevant table entries are in the matching bytes in 'bx'.
Then, it's similar for 32-bit or 64-bit loads.
32-bit:
mov eax, [input + offset]
bswap eax
mov ebx, 0
or ebx, [table_source_primary + (eax && (0xff << 8 * 0 )) ]
or ebx, [table_source_primary + (eax && (0xff << 8 * 1 )) ]
or ebx, [table_source_primary + (eax && (0xff << 8 * 2 )) ]
or ebx, [table_source_primary + (eax && (0xff << 8 * 3 )) ]
# ...
mov [ptr_offset], offset + 4
64-bit:
mov rax, [input + offset]
bswap rax
mov rbx, 0
or rbx, [table_source_primary + (rax && (0xff << 8 * 0 )) ]
or rbx, [table_source_primary + (rax && (0xff << 8 * 1 )) ]
or rbx, [table_source_primary + (rax && (0xff << 8 * 2 )) ]
or rbx, [table_source_primary + (rax && (0xff << 8 * 3 )) ]
or rbx, [table_source_primary + (rax && (0xff << 8 * 4 )) ]
or rbx, [table_source_primary + (rax && (0xff << 8 * 5 )) ]
or rbx, [table_source_primary + (rax && (0xff << 8 * 6 )) ]
or rbx, [table_source_primary + (rax && (0xff << 8 * 7 )) ]
# ...
mov [ptr_offset], offset + 8
Using the MMX registers these are much alike the 64-bit case.
movq mm0, [input_base + input_offset]
mov mm1, 0
por mm0, [table_source_primary + (mm0 && (0xff << 8 * 0 )) ]
por mm0, [table_source_primary + (mm0 && (0xff << 8 * 1 )) ]
por mm0, [table_source_primary + (mm0 && (0xff << 8 * 2 )) ]
por mm0, [table_source_primary + (mm0 && (0xff << 8 * 3 )) ]
por mm0, [table_source_primary + (mm0 && (0xff << 8 * 4 )) ]
por mm0, [table_source_primary + (mm0 && (0xff << 8 * 5 )) ]
por mm0, [table_source_primary + (mm0 && (0xff << 8 * 6 )) ]
por mm0, [table_source_primary + (mm0 && (0xff << 8 * 7 )) ]
# ...
mov [ptr_offset], offset + 8
About the various masks starting to get introduced, is where
it's figured they would make a lookup table, figuring the cache
would be warm, or as to whether instead it's better to interleave
them among the remaining registers, their computations.
mov mm1, 0
mov mm7, 0xFF
shl mm7, 8
mov mm6, 0
por mm6, mm7
por mm1, [table_source_primary + (mm0 && (0xff << 8 * 0 )) ]
About the register allocation, is the idea to either make the
locals first and temporaries last or temporaries first and locals
last, which seems preferable, since sometimes the default instruction
works on the lower registers, making sense to have that on temporaries.
About the memory address offset, it's a usual sort of temporary,
then about computing offsets that they go either on the general
registers or the (later) extended registers, while it seems that the
MMX instructions are limited about the "parallel" instructions,
with regards to that movd/movq are perhaps for simply pushing
the lookups onto the call stack, then loading relative the call-stack.
https://community.intel.com/t5/Intel-ISA-Extensions/Software-consequences-of-extending-XMM-to-YMM/td-p/872131
This suggests that MMX is simply obsolete, yet, there's also the idea
that it's still an available execution unit, and runs at the chip's speed, about making the general purpose and mmx registers work together,
then about altogether separately the sse/avx xmm/ymm/zmm registers.
Then, while MMX registers are independent moves and have no push/pop,
yet there is "PSHUFB" on MMX registers. There are MOVD and MOVQ.
So, the MMX registers can be useful for PSHUFB about the general registers, and PCMP*B, then that PMOVMSKB will result an 8-bit sequence from
8-byte PCMP*B.
Then, the targets for x86-64 appear along the lines of:
1) G.P. + MMX r*x + mm (64, 64 bits, 7, 8 many)
2) SSE xmm (128 bits, 8 many)
3) AVX ymm -> zmm (256, 512 bits wide, 8, 16 many)
Similarly for ARM:
1) G.P. + NEON
2) SVE
Then, the idea here is that there are to be approaches
for the
1) solid (a constant block, length known at run-time)
2) stream (a constant block, length un-known at runt-time)
then as with regards to "incremental approaches" or changes,
that being in terms of those.
The usual corpus is either the
1) source (code and data)
2) spoken (natural language)
as that being text among the
1) text
2) binary.
The basic machines are as of "match" and "find",
1) match-next
2) find-first
about that the accepters/rejecters are to make for
both the alternatives of a "next" and signature of a "first".
Then, the usual idea is that "findings" are "found",
and "matchings" are "made".
The usual idea then is that finding and matching make
for that finding is the process, and matching is the productions.
Matching a mis-match and made-match: the usual meaning
of "mis-match" means a false positive, yet here it aligns with
the accepters and rejecters, or acceptors and rejectors,
with the idea that finding is a parallel algorithm along
the lines of:
find-longest-match
find-nearest-exit
with the idea that any kind of finding has both continuing
and terminating conditions, then that accepters and rejecters
are to be run in parallel, for example, with starting to find the
longest match and working backward (on the input register),
and starting to find the nearest exit and working forward
(on the input register).
The predicates off the properties are to be computed, here
for a usual account of
1)intersections,
2) unions
about the ranges and range calculus of characters that
comprise a class, alike
1) simple classes (word, space, digit, punctuation),
2) POSIX classes
3) Unicode classes
as built-in classes, then the user-defined classes as made
of combinations of those spaces, and, specific combinations
of characters, and + and - and Union and Intersection and Setminus.
The find-longest-match, then, is about making bitmasks of
long length to the predicates, then working those backward,
the accepters.
The find-nearest-exit, is about making bitmasks of matching
_not_ the predicate, then working that forward, the rejecters.
There are distinguished
the character "properties" computed
and the finder/matcher ("match-finder", "match-maker")
the "predicates" computed, then about making so that
usually it's AND and OR for the conjunctive and disjunctive
and as about XOR and NAND, then about bits that are "care"
and bits that are "don't care", to result then that a loop of
evaluations in a linear-constant constant time in a branchless
manner make arithmetic that accumulates then what can be
tested for made-matches or mis-matches (acceptance, rejection).
Much like the "layers" are about the
abstract syntax sequence
abstract syntax lattice (grid)
abstract syntax tree
abstract syntax graph (links)
then as well the finder and matcher have "layers" involved
about default semantics for counting and summary, where
the finder automatically makes counts and summary, like
average and "clear modes", when there are obvious modes,
while the matcher is to be building "catalog" and "dictionary".
So, the "layers" are as of the state machine, the idea that any
state machine of "matchings" is many, many loops of "findings",
then a given matching gets the accumulated finding as metadata,
besides also being the location down the layers in the lattice and the
grid.
The layers develop the properties or prop-bits, in the variable-length encoding, of the codes/text, in-place.
byte-props (the bytes, which are chars in ASCII)
char-props (chars in UTF-8)
...
esc-props (the escapement and literals)
lig-props (ligatures, accents, ..., locale collation)
Besides these default properties (binary properties)
then each character in each character-set has its code-point,
or code-points, that are numeric value (an unsigned integer).
Then, for particular classes (character classes) that are either derived
from the common props, when they are exclusive or indicative, those
are common and byte-props and char-props are always computed
(via lookup and decoding), then the idea is that otherwise the character classes are defines by ranges and points, then about that there's logic involved that takes the literal codepoint values of the characters,
and derives/computes their presence in ranges (of spaces) or
membership in sets of points.
So, the general idea is that for a given scanning/tokenization/lexing,
that the relevant character classes are decomposed from the expression
or grammar, then the arithmetic is defined that according to the numeric values in the ranges and of the points of the characters, that the
indicators
for all the characters are derived from the prop-layers and the characters.
expr-1-props (expression properties)
expr-2-props
...
gram-1-props (grammar properties)
gram-2-props
...
Then, the scanner has states, about what it's expecting to scan, and the
idea
above about the coded likely/less-likely/un-likely current and next
states of
the scanner, then that scanning proceeds with its char-props,
expr-props, gram-props,
figuring those are computed all the time, and then arithmetic follows,
where thusly
it results that AND/OR and CMP result deriving the findings and matchings.
A fixed value (a la "grep --fixed") or a constant string to match, is
its own sort of
case, instead of having simply an expression/grammar with each of the characters
of the string literal in order, makes for making a mask directly off the codepoints
and matching off that (longest-match and nearest-exit).
Making bitmasks that are aligned down the bytes, gets involved the variable-length
when the characters are variable-length, and besides "stitching" when
the characters
their bytes cross or "straddle" boundaries, stitching the straddlings.
The point here
is that the bit masks gets rotated or shifted or grown, for greedy
match, and then
when those go over variable length characters, need get "smeared" across
the
variable-length, and when rotating or shifting, the relevant pattern
needs get
smeared and un-smeared, so that the care/dontcare bits line up, that the word-wide
AND/OR in effect indicates the findings and thusly matchings.
The java.util.regex.Pattern class is considered a good design for
regular expressions.
The java.lang.Character describes many relevant predicates, or their properties.
https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html https://docs.oracle.com/javase/8/docs/api/java/lang/Character.html
The javadoc well-describes how UTF-16 makes a variable-length encoding
of otherwise what are usually called "wide characters" or two-byte fixed-length,
when the high-low surrogates beyond the Basic Multilingual Plane (> 0xFFFF) make either 2-bytes or 4-bytes each character.
When the characters have 2-bytes instead of 1-byte, yet the masks are organized
their indices and offsets character-wise, then like "smearing" is
"smashing", basically
doubling out the bits, thus that "smashing" for wide characters and "smearing" for
variable-length characters is how to make bitmasks that then the properties/predicates
are derived and computed with arithmetic, and the findings and matchings
are products
of arithmetic of the properties/predicates, then that the
indices/offsets are maintained
by the smashing/smearing.
Then, since the machine itself (or the framework) makes the smashing and smearing,
then the crafters or generators of the patterns for the findings and arcs/plants for
the matchings, can do so agnostic the character-set encoding (as long as
it's Unicode,
where other character-sets relate various symbols and glyphs in their glyph-maps to
their code-points, then that those would have their own craftings or generators of
what computes the predicates from the properties).
About the fixed case, is that it can operate on the codepoints
themselves, that it's
not agnostic the character set, instead the string representation has a conversion
loaded to the character set on a register, then that's simply XOR'ed
with the codepoints
and results testing for zero (instead of the overall approach of
arithmetic on the
properties and predicates and then after CMP to make something like MOVMSKB which moves a mask of the bits out then to make find-first-set, find-first-clear,
or as with regards to bit-scan-forward, finding the offsets where the findings
begin and end, to make matchings the productions. So, keywords and search strings can make find-longest-match find-nearest exit in a constant
time, then
for straddling and splitting when crossing the boundaries of the loaded
word.
So, in the layers and layers, then both the char-props and code-points
get involved,
where the text data is in its own character set in its own layout. Both
get involved
in all cases, since the coded/* primary byte-props stick out what makes
to derive
the extents of the code-points, and, there may be multiple code-points
in a "character".
https://en.wikipedia.org/wiki/Code_point
About then the algorithms and the machine, it's figured that the
find-longest-match
find-nearest-exit
has that there are many alternatives to be checked for their initial segments,
with the idea of matching the "constant/fixed" and the "variable/greedy" productions,
about that all the alternatives are making findings in the usual course
of exhibiting
the same behavior as the "L*" parsers, LL and LR parsers, and with
regards to
look-ahead. The idea is to address a superset of context-free grammars as the "context-local" or "context-bracketd" grammars, where for example cases of ambiguity like matching brackets vis-a-vis '>>' and '<<', make for
that there's
nesting of brackets or alike a depth-stack, vis-a-vis the plain space of expressions.
Then, when "combining matches", is about either bit-flags or primes as
for the bit-sets or prime-multisets, about figuring the queue/lists of finders their bitmasks, and when evaluating those about how to accumulate which ones make or might-be matches, and then how to sort among those, basically that when a match is made the finder is promoted, then
figuring that
among the array/queue/list of possible finders, of which there may be more than fit on registers, that they are to be gone through. Here, where
mostly
with the mind to be avoiding "conditional jumps" or branches, then also
is the notion to avoid "memory references" or stalls, about the stall-less after the branch-less, and figuring that a "linear-constant constant time", has that the CPU has all day if there are no branches and less stalls.
char* strtok(
char* _Nullable restrict str,
const char* restrict delim
)
char* strtok_r(
char* _Nullable restrict str,
const char* restrict delim,
char** restrict saveptr
);
https://www.pcre.org/current/doc/html/
Register Plan
So, there are these sorts registers.
gp: general purpose
ga: general auxiliary (MMX)
rv: vector registers
Then, on ARM, there are more general purpose registers,
figuring that the machine on x86 will be using the gp and ga,
and on ARM similarly dividing the registers into gp and ga,
and that on both ARM and x86 then there are vector registers.
x86
gp: 6-7 many
ga: 8 many
rv: 8 many (SSE 4.2) 16 many (AVX) 32 many AVX 512
ARM
gp + ga: 31 many
rv: 32 many
Then, it's figured that the machine thusly has:
gp + ga: 14-15 many
rv: 8-many
registers to be planned. Then, on the gpga registers,
it's figured to maintain the state of the machine, as
with regards to the stack, and on the rv registers,
it's figured to make the data, then that the algorithms
run on the machine on the data.
rv1: the text, the bytes
rv2: primary props (2-nybble)
rv3: secondary props (2-nybble)
rv4: unicode props (2-nybble)
Then, "the algorithms", of, "the machine" are to be figured
out, for what is the state of the machine, of, the states of
the machines, given by the inputs and the tables.
The usual idea is that the state of the machine accumulates
offsets and what are the emittings of the matchings of the
productions, so that mostly it's the states of the offsets,
and the partial accounts of the splitting and stitching,
above the smearing and smashing. These are on the
gp+ga registers, and the instructions there are mostly
spinning the machine.
Then the entries (table entries) and algorithm is to load
or construct a bit-mask, then for general sorts of the recognizers,
then the routine of the algorithm, derives with logical operations,
what results the findings.
Examples then begin to suggest themselves.
match \s+, one or more space characters
The predicate is aligned with the property white/*,
thus any of those bits set is a match. Then, the idea
is that the vector registers have "saturating/clamped
integer arithmetic". So, the predicate has any matching bits,
when AND'ed together, results a non-zero byte, then multiplying that
by 0x7F, will result 0xFF, that the high-bit is set. Then, PMOVMSKB
will make a bit-sequence of that, then for find-first-set.
match "cat", the fixed work "cat"
The matching is on the code-points. The idea is to construct
the "predicate" by first loading "cat" onto a register, otherwise
zeros. Then, XOR that with the code-points. Since it's figured
that the code-points aren't usually zero, then only the bytes
matching in sequence will be "cat". Then, applying the saturation/clamp
to those, then a sequence of 3 0 bit's after MOVMSKB is the what would
be "cat", with the non-matching characters being 1's, then for find-first-clear
and find-first-set, or finding three consecutive 0 bits for the first
match.
The idea is that these sorts of tests are independent the position,
that each of the offsets in the word (when un-split/un-straddled),
can be tested by rotating the mask and testing the rotated mask.
Then, it looks like there's packed-byte saturate subtract, yet
not seeing packed-byte saturate mul, ..., there are PADDUSB
and PSUBUSB, ....
Since not all the bits are expected to be set, another notion
is to use PSHUFB, on the nybbles, about which nybbles are
relevant, then that PSHUFB will result unambiguously the
high-bit set, then for bsf/ffs.
There's an idea then to take the bytes and make two products
and then blend those together, or as with regards to shuffle,
about going out to 16-bit space and then resulting back in
with packing to 8-bit saturated.
https://fgiesen.wordpress.com/2024/10/26/why-those-particular-integer-multiplies/
https://fgiesen.wordpress.com/2026/06/21/pivco-huffman-merge-operations/
About parsing and grammars and their complexity, is the idea
that when there is a brief account of "quoting" and "bracketing",
then it's possible to maintain a stack of the depth of various
quotes and brackets according to their nesting and escapements,
about the rules of quoting and the balancing of brackets.
Then, it's figured that some kinds of parsers are thusly able to
parse grammars with otherwise ambiguities, about the context
of the state machine of the parser.
The parser basically starts with a notion of "modes", about when
the parser is to be "invalidating" or "recognizing" or about how and
when it's to emit its productions, and about "debug/diagnostic" mode,
and these sorts of things.
What gets involved in the establishment and maintenance of state,
is about how much memory is on the side, and whether it's a brief
amount, or whether it's on the order of the input size, which is
the usual idea of building the layers.
So, the machine is to be having a variety of finders and matchers,
their forms of "properties".
1) bit-flags: closed categories, one or more, refining category
2) range-ends: ranges of code-points, a pair, base and extent
3) code-points: the code-points themselves, a list of lists
The bit-flags matcher is according to 1-many matches, where
the patterns in the bit-flags are templates to match runs of characters, 1-bits indicating.
The range-ends matcher would be a bound then positive or negative
offset, with regards to the difference of the value and base compared
to the range, then similarly for patterns in those.
The code-points themselves are for exact match, with the xor and
0-bits indicating.
Then, the matching will have offsets or the context of the straddling,
and about a stack of packed accumulators, then the bounds within
the word where the match is tried, and then that the bounds of the
match is what results the finding.
Then, for defining the "machine", is the idea that there's a reference implementation in the higher-level language, then that it models
the operation in the lower-level language, then that the facility
will be available and use the resources available.
About matching fixed-strings, may be for matching arbitrary
strings or words, then after that, matching for the fixed-strings,
for example having a length table and matching shorter fixed-strings,
like keywords in the language.
Then, about "attribute grammars" and "affix grammars", is about
the quoting and comments, and the sub-languages, about that
"language is built of languages", then as with regards to the
states (or modes) of the state machine, and about the finding-machines
and matching-machines, about making a standard algorithm that
efficiently results matches (then productions).
https://man7.org/linux/man-pages/man5/locale.5.html
The locale in the C and POSIX environments makes for
conventions about collation (sorting) and formatting,
and language and character-set encoding.
https://man7.org/linux/man-pages/man7/charsets.7.html
https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap07.html#tag_07
So, "vector-wide scalar word" ("Viswath") and "character machines" ("Charmaigne") is being defined in these ways.
Then, the POSIX and C/libc accounts of locale get involved,
for providing implementations of same.
The localedef brings an interesting example that it may define
its own comment and escape characters, then to be in effect,
a similar example is in SQL, where some commands indicate
their own escapes (of wildcards). Then another case is the
triple quotes: single quotes like in the shell, double quotes
like in Java, or backticks in Markdown, when the matching
would work down from the triple quotes.
The "Common Locale Data Repository", https://cldr.unicode.org/ ,
makes available data from Unicode.
About lookup-tables then lookup-trees as to be backed by
lookup-files, is about an idea that when lookups occur,
they're most direct when small enough to fit in 2^8 or so,
about that 2^10 is about 1024 then 2^20 is about a megabyte
and 2^30 is about a gigabyte. Then the idea of a lookup-trie
or lookup-tree is alike a hash-trie then for an LRU-eviction
policy to populate it with common values, and fall-back to
the lookup-file. Then that would be part of vwsw.
About collation then, is about what rules make exceptions
to otherwise the rule of that the code-points are already
the default lexicographic (sorting) order. The idea is to
make a lookup of exceptions, then for those to give the
base character which is its neighbor and in the default ordering,
then that the comparator for the sort operates on either that,
or the comparator to the base character, or the difference among
similar derived characters.
About the jump tables, one idea is to use lea according to
the various registers sizes, about making multiples of 2, 4, 8
in one instruction along with an add, about btree logic,
that the paths into the btree get computing with a dedicated
instruction, that happens to be lea/leaq, or the variations
among the registers what are the constant multiples,
instead of immediates.
Then, the goal is to make a low-level implementation, that
also has a high-level implementation, and that the interface
is the same, with that there are built-ins for the most usual
sorts of finders and matchers, and then that the machines
are of a flexible connectivity, where the high-level can use
the same routines, of the jump-tables and nop-fields, that
the low level uses, and that in the low-level, that the configurations
are made intrinsics, about making for the:
call-less
branch-less
stall-less
in the low-level, yet the logic in a high-level reference implementation,
is as well using the same data structures for the machines, according
to the offsets computed, and the instruction executed, and the
way that the routine is implemented, to be portable in the high-level,
and performant in the low-level, and from the same artifacts,
of what are the compilations of the regular expressions and grammars.
In the high level this could be lists of functions then invoking them,
where the next function to be invoked is computed like the offset
in the jump table (the branch table of the compiled instructions).
https://eli.thegreenplace.net/2012/07/12/computed-goto-for-efficient-dispatch-tables
About the base character class (or "ascii" class), with
alnum/
punct/
white/
coded/
then ideas include that the coded section includes that
for the terminal codes there are basically unbounded regions
following, indicating terminal escape, then that for UTF-8,
a secondary/auxiliary class would maintain the length of
the code and the offset of the code
length: 1|2|3|4 bit
offset: 1|2|3|4 bit, or 4|3|2|1 for "bytes remaining"
while the properties for the character itself would be
duplicated under each of the bytes, as above about
"smearing" and "smashing" the properties and predicates.
About the base character class and whether "punctuation"
or "symbols" is the idea, is that abstractly they're punctuation
and match the POSIX punctuation class, then that "symbols"
are not only the codes themselves of any sort, then that among
classes of symbols (eg, playing cards, chess pieces, musical notes, mathematical formulary, ...) is that those have their own classes.
Hello, here I'll post some design notes and a panel discussion with some chat-bots about making some sense of the "vector-wide scalar word"
and "character machines", on commodity hardware about ubiquitous
operations.
It's considered at least tangentially relevant to comp.lang.c and comp.lang.c++ because for example text is ubiquitous and the targets
would be low-level, while the higher-level languages would have a
same sort of patternry, and for example that libc and cstdlib are
standard, and as with regards to POSIX and Unicode and so on.
Please feel free to excuse or ignore, or comment as freely.
Thanks for reading.
Good-day and good-bye.Thanks for reading.
On 28/07/2026 2:43 AM, Ross Finlayson wrote:
Hello, here I'll post some design notes and a panel discussion with some
chat-bots about making some sense of the "vector-wide scalar word"
and "character machines", on commodity hardware about ubiquitous
operations.
It's considered at least tangentially relevant to comp.lang.c and
comp.lang.c++ because for example text is ubiquitous and the targets
would be low-level, while the higher-level languages would have a
same sort of patternry, and for example that libc and cstdlib are
standard, and as with regards to POSIX and Unicode and so on.
Please feel free to excuse or ignore, or comment as freely.
Thanks for reading.
Are you generating all of your code via LLMs? Rest assured,
the LLM generated code will have subtle and sometimes not so subtle
bugs.
Happy bughunting!
On 07/27/2026 11:47 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 28/07/2026 2:43 AM, Ross Finlayson wrote:
Hello, here I'll post some design notes and a panel discussion with some >>> chat-bots about making some sense of the "vector-wide scalar word"
and "character machines", on commodity hardware about ubiquitous
operations.
It's considered at least tangentially relevant to comp.lang.c and
comp.lang.c++ because for example text is ubiquitous and the targets
would be low-level, while the higher-level languages would have a
same sort of patternry, and for example that libc and cstdlib are
standard, and as with regards to POSIX and Unicode and so on.
Please feel free to excuse or ignore, or comment as freely.
Thanks for reading.
Are you generating all of your code via LLMs?˙ Rest assured,
the LLM generated code will have subtle and sometimes not so subtle
bugs.
Happy bughunting!
Heh, no, I write my own code, yet, words are words and those agree.
Hi,
Rossy Boy is neither Einstein nor Zweistein.
He is not Einstein since Einstein is already dead:
Albert Einstein (1879 - 1955)
https://de.wikipedia.org/wiki/Albert_Einstein
He is also not Zweistein, since he doesn't
understand concepts such as:
- NVIDIA Volta ff. architecture
Also his hands are small, and his breath stinks,
and he lives in the basement of his mother.
Bye
Ross Finlayson schrieb:
Good-day and good-bye.Thanks for reading.
Hi,
There is doubt, that you write code.
How do you write code, with your
asshole? I mean you even don't under-
stand a simple LIPS budget post?
Bye
Ross Finlayson schrieb:
On 07/27/2026 11:47 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 28/07/2026 2:43 AM, Ross Finlayson wrote:
Hello, here I'll post some design notes and a panel discussion with
some
chat-bots about making some sense of the "vector-wide scalar word"
and "character machines", on commodity hardware about ubiquitous
operations.
It's considered at least tangentially relevant to comp.lang.c and
comp.lang.c++ because for example text is ubiquitous and the targets
would be low-level, while the higher-level languages would have a
same sort of patternry, and for example that libc and cstdlib are
standard, and as with regards to POSIX and Unicode and so on.
Please feel free to excuse or ignore, or comment as freely.
Thanks for reading.
Are you generating all of your code via LLMs? Rest assured,
the LLM generated code will have subtle and sometimes not so subtle
bugs.
Happy bughunting!
Heh, no, I write my own code, yet, words are words and those agree.
On 07/27/2026 03:25 PM, Mild Shock wrote:
Hi,
There is doubt, that you write code.
How do you write code, with your
asshole? I mean you even don't under-
stand a simple LIPS budget post?
Bye
Ross Finlayson schrieb:
On 07/27/2026 11:47 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 28/07/2026 2:43 AM, Ross Finlayson wrote:
Hello, here I'll post some design notes and a panel discussion with
some
chat-bots about making some sense of the "vector-wide scalar word"
and "character machines", on commodity hardware about ubiquitous
operations.
It's considered at least tangentially relevant to comp.lang.c and
comp.lang.c++ because for example text is ubiquitous and the targets >>>>> would be low-level, while the higher-level languages would have a
same sort of patternry, and for example that libc and cstdlib are
standard, and as with regards to POSIX and Unicode and so on.
Please feel free to excuse or ignore, or comment as freely.
Thanks for reading.
Are you generating all of your code via LLMs? Rest assured,
the LLM generated code will have subtle and sometimes not so subtle
bugs.
Happy bughunting!
Heh, no, I write my own code, yet, words are words and those agree.
Perhaps take a look on comp.lang.java.programmer, for example
where is given a simple way to make "Web APIs" in "Java",
with cool elite tech like "JSON" and "HTTP".
"APIs", I learned that word in 1994 working at "The Electronic Messaging Association", which no longer so much exists
in its current form.
Most of my code is doing work in prod, and has been for
decades, long after I logged out one of my dozens of aliases,
I even wrote a few lines of code in Windows, though I
lean more toward HP and Micron than Microsoft and NVIDIA.
I've written frameworks in front-end and back-end,
and about system code and theory,
and around the whole damn stack.
"These motes excitate a mouse brain immensely".
Anyways, about "vectorizing string functions"
and "vectorizing regular expressions"
and "vectorizing parsers", that's what Viswath & Charmaigne is about,
I'd be curious your inputs if you can ignore the trolls,
like the sock-puppet farm here. It's basically figured useful
for, for example, deep inspection of Internet messages, or incremental parsing, when implementing the text Internet protocols.
Then, yes, it's not so relevant to "the Foundations of Mathematics
and Physics", directly, yet it is to systems programming.
On 07/27/2026 03:48 PM, Ross Finlayson wrote:
On 07/27/2026 03:25 PM, Mild Shock wrote:
Hi,
There is doubt, that you write code.
How do you write code, with your
asshole? I mean you even don't under-
stand a simple LIPS budget post?
Bye
Ross Finlayson schrieb:
On 07/27/2026 11:47 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 28/07/2026 2:43 AM, Ross Finlayson wrote:
Hello, here I'll post some design notes and a panel discussion with >>>>>> some
chat-bots about making some sense of the "vector-wide scalar word" >>>>>> and "character machines", on commodity hardware about ubiquitous
operations.
It's considered at least tangentially relevant to comp.lang.c and
comp.lang.c++ because for example text is ubiquitous and the targets >>>>>> would be low-level, while the higher-level languages would have a
same sort of patternry, and for example that libc and cstdlib are
standard, and as with regards to POSIX and Unicode and so on.
Please feel free to excuse or ignore, or comment as freely.
Thanks for reading.
Are you generating all of your code via LLMs? Rest assured,
the LLM generated code will have subtle and sometimes not so subtle
bugs.
Happy bughunting!
Heh, no, I write my own code, yet, words are words and those agree.
Perhaps take a look on comp.lang.java.programmer, for example
where is given a simple way to make "Web APIs" in "Java",
with cool elite tech like "JSON" and "HTTP".
"APIs", I learned that word in 1994 working at "The Electronic Messaging
Association", which no longer so much exists
in its current form.
Most of my code is doing work in prod, and has been for
decades, long after I logged out one of my dozens of aliases,
I even wrote a few lines of code in Windows, though I
lean more toward HP and Micron than Microsoft and NVIDIA.
I've written frameworks in front-end and back-end,
and about system code and theory,
and around the whole damn stack.
"These motes excitate a mouse brain immensely".
Anyways, about "vectorizing string functions"
and "vectorizing regular expressions"
and "vectorizing parsers", that's what Viswath & Charmaigne is about,
I'd be curious your inputs if you can ignore the trolls,
like the sock-puppet farm here. It's basically figured useful
for, for example, deep inspection of Internet messages, or incremental
parsing, when implementing the text Internet protocols.
Then, yes, it's not so relevant to "the Foundations of Mathematics
and Physics", directly, yet it is to systems programming.
"When compiling legacy PTX code (ISA versions prior to 3.0)
containing [...], the compiler silently disables use of the ABI."
"Would you like to buy a bridge that's also a boat?
It's rocking all over the place."
The specs and stable, backward compatible definitions of modern
commodity CPUs are around, people even collect them over time, they're
even in PDFs, in case you want to read one without looking over your own electronic shoulder.
Which defines the ABI, ....
He is also not Zweistein, since he doesn't
understand concepts such as:
- NVIDIA Volta ff. architecture
They're considered really quite simple,
each of those threads is simple, SIMT.
Hi,
Moron there is no SIMT. As I already wrote:
He is also not Zweistein, since he doesn't
understand concepts such as:
- NVIDIA Volta ff. architecture
But you had the SIMD and MIMD disctinction
alreay in OpenMP (via #pragma omp simd and
#pragma omp parallel(:
Flynn's Taxonomy classifies computer
architectures according to how many
instruction streams (processes) and
data streams they can process simultaneously,
dividing them into four categories:
SISD, SIMD, MISD, and MIMD. https://www.geeksforgeeks.org/computer-organization-architecture/computer-architecture-flynns-taxonomy/
Its not so difficult to understand what
the NVIDIA Volta ff. architecture.
Bye
Ross Finlayson schrieb:
They're considered really quite simple, each of those threads is
simple, SIMT.
On 07/28/2026 02:25 AM, Mild Shock wrote:
Hi,
Moron there is no SIMT. As I already wrote:
He is also not Zweistein, since he doesn't
understand concepts such as:
- NVIDIA Volta ff. architecture
But you had the SIMD and MIMD disctinction
alreay in OpenMP (via #pragma omp simd and
#pragma omp parallel(:
Flynn's Taxonomy classifies computer
architectures according to how many
instruction streams (processes) and
data streams they can process simultaneously,
dividing them into four categories:
SISD, SIMD, MISD, and MIMD.
https://www.geeksforgeeks.org/computer-organization-architecture/computer-architecture-flynns-taxonomy/
Its not so difficult to understand what
the NVIDIA Volta ff. architecture.
Bye
Ross Finlayson schrieb:
They're considered really quite simple, each of those threads is
simple, SIMT.
Mein Hut hat drei Ecken
Drei Ecken hat mein Hut
Three models of continuous domains,
three laws of large numbers,
three models of Cantor spaces,
three laws of limit theorems,
three probabilistic limit theorems,
three uniform distributions of the naturals,
....
Drei Ecken hat mein Hut.
This is with infinity and continuity,
SIMT is a worker pool.
Zero paradoxes.
Its actually quite amazing. Gemini, DeepSeek,
OpenAI all know Dmitriy V'jukov. I have asked
the IntelliJ integrated Freeium AI to generate
some code for me, I guess their service uses
by default OpenAI (Codex), and had it reviewed
by Gemini and DeepSeek. These AIs started lecturing
me about lazySet() in Java. But I went with set():
private static boolean enqueue(Queue q, Object data) {
int pos = q.enqueuePos.get();
for (; ; ) {
int index = pos & q.bufferMask;
int seq = q.sequences.get(index);
int dif = seq - pos;
if (dif == 0) {
if (q.enqueuePos.compareAndSet(pos, pos + 1)) {
q.data[index] = data;
q.sequences.set(index, pos + 1);
return true;
}
pos = q.enqueuePos.get();
} else if (dif < 0) {
return false;
} else {
pos = q.enqueuePos.get();
}
}
}
The above version seems to be more suitable
for my purpose, since it allows polling, it
basically implements offer(). While the
version posted on in the lock free group
by Chris M. Thomasson implements a spin wait
blocking put() already.
Hi,
Confused rossy boy is confused. We are
not building a stupid web server, where
a listener thread spawns service threads,
and to avoid malloc and free, reuses
a pool, or some shitty fork join framework.
The producer and consumer example I posted
elsewhere archived a dataflow without
malloc and free of threads. You are miles
away from what we are doing here.
Bye
Ross Finlayson schrieb:
On 07/28/2026 02:25 AM, Mild Shock wrote:
Hi,
Moron there is no SIMT. As I already wrote:
He is also not Zweistein, since he doesn't
understand concepts such as:
- NVIDIA Volta ff. architecture
But you had the SIMD and MIMD disctinction
alreay in OpenMP (via #pragma omp simd and
#pragma omp parallel(:
Flynn's Taxonomy classifies computer
architectures according to how many
instruction streams (processes) and
data streams they can process simultaneously,
dividing them into four categories:
SISD, SIMD, MISD, and MIMD.
https://www.geeksforgeeks.org/computer-organization-architecture/computer-architecture-flynns-taxonomy/
Its not so difficult to understand what
the NVIDIA Volta ff. architecture.
Bye
Ross Finlayson schrieb:
They're considered really quite simple, each of those threads is
simple, SIMT.
Mein Hut hat drei Ecken
Drei Ecken hat mein Hut
Three models of continuous domains,
three laws of large numbers,
three models of Cantor spaces,
three laws of limit theorems,
three probabilistic limit theorems,
three uniform distributions of the naturals,
....
Drei Ecken hat mein Hut.
This is with infinity and continuity,
SIMT is a worker pool.
Zero paradoxes.
Hi,
Confused rossy boy is confused. We are
not building a stupid web server, where
a listener thread spawns service threads,
and to avoid malloc and free, reuses
a pool, or some shitty fork join framework.
The producer and consumer example I posted
elsewhere archived a dataflow without
malloc and free of threads. You are miles
away from what we are doing here.
On 29/07/2026 5:15 PM, Mild Shock wrote:
Hi,
Confused rossy boy is confused. We are
not building a stupid web server, where
a listener thread spawns service threads,
and to avoid malloc and free, reuses
a pool, or some shitty fork join framework.
The producer and consumer example I posted
elsewhere archived a dataflow without
malloc and free of threads. You are miles
away from what we are doing here.
Why not?˙ Isn't this comp.lang.c?˙ And isn't that exactly how
CivetWeb works internally?˙ Have you never built your own web
sever in C?˙ Not even with CivetWeb?˙ It's really easy!˙ You
only need to implement a callback or two.
Hi,
Nobody cares about CivetWeb a C++/C library,
the rossy boy moron refuses to understand this
simple GPU test, that shows some AI Acceleration:
On 29/07/2026 5:27 PM, Mild Shock wrote:
Hi,
Nobody cares about CivetWeb a C++/C library,
the rossy boy moron refuses to understand this
simple GPU test, that shows some AI Acceleration:
I don't know about you, but I don't run my webserver on my GPU.˙ I use
it strictly for graphics.
Hi,
Nobody cares about CivetWeb a C++/C library,
the rossy boy moron refuses to understand this
simple GPU test, that shows some AI Acceleration:
11.4 Giga Lips with a Budget Laptop https://github.com/Jean-Luc-Picard-2021/gigabudget
Bye
Johann 'Myrkraverk' Oskarsson schrieb:
On 29/07/2026 5:15 PM, Mild Shock wrote:
Hi,
Confused rossy boy is confused. We are
not building a stupid web server, where
a listener thread spawns service threads,
and to avoid malloc and free, reuses
a pool, or some shitty fork join framework.
The producer and consumer example I posted
elsewhere archived a dataflow without
malloc and free of threads. You are miles
away from what we are doing here.
Why not?˙ Isn't this comp.lang.c?˙ And isn't that exactly how
CivetWeb works internally?˙ Have you never built your own web
sever in C?˙ Not even with CivetWeb?˙ It's really easy!˙ You
only need to implement a callback or two.
Hi,
Your strictness is your problem , not mine.
The WebGPU / WGSL has explicitly an API
for so called compute shaders.
You can also combine compute shaders and
render shaders. But to use compute shaders
for AI acceration is not uncommon now.
Hi,
You see it all boils down to find your inner peace
by an immaculate inception of some queue datatype.
KOAN/Fortran-S was an early 1990s research programming
system for distributed-memory multiprocessors . Developed
at ENS Lyon in the early 1990s . Often listed alongside
other historical parallel programming efforts.
The Message Passing: The research explicitly
compared the SVM approach against message passing
on the same hardware . The finding was that SVM
could achieve good performance without the low-level
complexity of managing explicit messages, though
the best results often came from a hybrid approach (sic!)
Here is an interesting baseline, from Java,
a class ElevenSingle that only does:
public static void run() {
for (int A = 1; A < 192; A++) {
int Y = (771-A)/3;
for (int B = A; B < Y; B++) {
int Z = (771-A-B)/2;
for (int C = B; C < Z; C++) {
int D = 711-A-B-C;
if (A*B*C == 711000000/D &&
711000000 % D == 0)
System.out.println("A="+A+", B="+B+", C="+C+", D="+D);
}
}
}
}
And then compare it to ElevenMulti, doing some
Work Balancing Scheduler Tetris Game with 8 cores:
ElevenSingle
A=120, B=125, C=150, D=316
6.628 ms
ElevenMulti
A=120, B=125, C=150, D=316
1.941 ms
Not great, not terrible!
Bye
On 29/07/2026 5:46 PM, Mild Shock wrote:
Hi,
Your strictness is your problem , not mine.
The WebGPU / WGSL has explicitly an API
for so called compute shaders.
You can also combine compute shaders and
render shaders. But to use compute shaders
for AI acceration is not uncommon now.
I know it's extremely common.˙ I just don't do it myself.
I don't even know what kind of GPU I have.˙ That's as much I care about
GPUs.˙ I only need my GPU to handle OpenGL 4.6.
Because we're in comp.lang.c, and I write my graphics in C, and not C++.
Nor Fortran 77, like my copy of /Digital Image Processing/ by Gonzales & Woods.˙ Just take a look at page 127, and bask in the glory of the /Fast Fourier Transform/ in Fortran 77.
That said, I kind of like classic Fortran, like 77, IV; and recently I learned there was Fortran 66.˙ I either didn't know that, or just
completely forgot about it.
Happy C coding, or Fortran 77!
Hi,
I am not in C, it is a theory and a C++
cross post. But I originally started elsewhere.
I am only reacting to a post that spilled
from C, theory and C++ back to else where,
since Rossy Boy extend the discussion.
Yes the FORTRAN reference is interesting!
See an older post of mine, where I tested
exactly the Queues idea, and where they
already mentiond hyprid approaches:
Hi,
You see it all boils down to find your inner peace
by an immaculate inception of some queue datatype.
KOAN/Fortran-S was an early 1990s research programming
system for distributed-memory multiprocessors . Developed
at ENS Lyon in the early 1990s . Often listed alongside
other historical parallel programming efforts.
The Message Passing: The research explicitly
compared the SVM approach against message passing
on the same hardware . The finding was that SVM
could achieve good performance without the low-level
complexity of managing explicit messages, though
the best results often came from a hybrid approach (sic!)
Here is an interesting baseline, from Java,
a class ElevenSingle that only does:
˙˙˙ public static void run() {
˙˙˙˙˙˙˙ for (int A = 1; A < 192; A++) {
˙˙˙˙˙˙˙˙˙˙˙ int Y = (771-A)/3;
˙˙˙˙˙˙˙˙˙˙˙ for (int B = A; B < Y; B++) {
˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙ int Z = (771-A-B)/2;
˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙ for (int C = B; C < Z; C++) {
˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙ int D = 711-A-B-C;
˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙ if (A*B*C == 711000000/D &&
˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙ 711000000 % D == 0)
˙˙˙ System.out.println("A="+A+", B="+B+", C="+C+", D="+D);
˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙ }
˙˙˙˙˙˙˙˙˙˙˙ }
˙˙˙˙˙˙˙ }
˙˙˙ }
And then compare it to ElevenMulti, doing some
Work Balancing Scheduler Tetris Game with 8 cores:
ElevenSingle
A=120, B=125, C=150, D=316
6.628 ms
ElevenMulti
A=120, B=125, C=150, D=316
1.941 ms
Not great, not terrible!
Bye
Feel free to also do these more logic tiling
experiments than signal processing experiments.
I don't do signal process with pi-WAM.
Bye
Johann 'Myrkraverk' Oskarsson schrieb:
On 29/07/2026 5:46 PM, Mild Shock wrote:
Hi,
Your strictness is your problem , not mine.
The WebGPU / WGSL has explicitly an API
for so called compute shaders.
You can also combine compute shaders and
render shaders. But to use compute shaders
for AI acceration is not uncommon now.
I know it's extremely common.˙ I just don't do it myself.
I don't even know what kind of GPU I have.˙ That's as much I care about
GPUs.˙ I only need my GPU to handle OpenGL 4.6.
Because we're in comp.lang.c, and I write my graphics in C, and not C++.
Nor Fortran 77, like my copy of /Digital Image Processing/ by Gonzales &
Woods.˙ Just take a look at page 127, and bask in the glory of the /Fast
Fourier Transform/ in Fortran 77.
That said, I kind of like classic Fortran, like 77, IV; and recently I
learned there was Fortran 66.˙ I either didn't know that, or just
completely forgot about it.
Happy C coding, or Fortran 77!
Hi,
Maybe there is a Rossy Boy flux generator
web server with infinity and continuity
HTTPS and .mjs type, aka SIMT halucination.
To run the GPU example that is written in HTML,
JavaScript and WebGPU / WGSL, the minium is
possibly a HTTPS server that can deliver the
right mime type for the .mjs extension. Its
then only a bundle of static pages that does
the demonstration. What worked on my side
is the IntelliJ browse button, which then uses
a small local server on its own, sandboxed to
serving some project files.
But this is only how to launch the test pages.
The Rossy Boy SIMT halucination, could also work, who knows?
Bye
Mild Shock schrieb:
Hi,
Nobody cares about CivetWeb a C++/C library,
the rossy boy moron refuses to understand this
simple GPU test, that shows some AI Acceleration:
11.4 Giga Lips with a Budget Laptop
https://github.com/Jean-Luc-Picard-2021/gigabudget
Bye
Johann 'Myrkraverk' Oskarsson schrieb:
On 29/07/2026 5:15 PM, Mild Shock wrote:
Hi,
Confused rossy boy is confused. We are
not building a stupid web server, where
a listener thread spawns service threads,
and to avoid malloc and free, reuses
a pool, or some shitty fork join framework.
The producer and consumer example I posted
elsewhere archived a dataflow without
malloc and free of threads. You are miles
away from what we are doing here.
Why not?˙ Isn't this comp.lang.c?˙ And isn't that exactly how
CivetWeb works internally?˙ Have you never built your own web
sever in C?˙ Not even with CivetWeb?˙ It's really easy!˙ You
only need to implement a callback or two.
On 07/27/2026 11:47 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 28/07/2026 2:43 AM, Ross Finlayson wrote:
Hello, here I'll post some design notes and a panel discussion with some >>> chat-bots about making some sense of the "vector-wide scalar word"
and "character machines", on commodity hardware about ubiquitous
operations.
It's considered at least tangentially relevant to comp.lang.c and
comp.lang.c++ because for example text is ubiquitous and the targets
would be low-level, while the higher-level languages would have a
same sort of patternry, and for example that libc and cstdlib are
standard, and as with regards to POSIX and Unicode and so on.
Please feel free to excuse or ignore, or comment as freely.
Thanks for reading.
Are you generating all of your code via LLMs? Rest assured,
the LLM generated code will have subtle and sometimes not so subtle
bugs.
Happy bughunting!
Heh, no, I write my own code, yet, words are words and those agree.
Then the idea is that any of those can be found and matched in
one "run", i.e. a stall-less, branch-less, call-less list of less than
a few or less than a few dozens or less than a few hundreds
instructions, the results "findings" in data and corresponding
"matchings" of expressions, that runs in less than one microsecond.
So, the context then is for register state and stack contents, that
the indicators of the above as "positive presence" then is to make
for that the adjustments to the offsets and extents and the shifts
is according to those, otherwise no-ops. Then the idea is that a
Hi,
You are still chewing on SIMD. LoL
Ross Finlayson schrieb:
Then the idea is that any of those can be found and matched in
one "run", i.e. a stall-less, branch-less, call-less list of less than
a few or less than a few dozens or less than a few hundreds
instructions, the results "findings" in data and corresponding
"matchings" of expressions, that runs in less than one microsecond.
You cannot make the mental translation that if you have:
Ross Finlayson schrieb:
So, the context then is for register state and stack contents, that
the indicators of the above as "positive presence" then is to make
for that the adjustments to the offsets and extents and the shifts
is according to those, otherwise no-ops. Then the idea is that a
As independent logical thread state, that automatically MIMD follosw?
Whats the problem to solve then?
Bye
Hi,
You are still chewing on SIMD. LoL
Ross Finlayson schrieb:
Then the idea is that any of those can be found and matched in
one "run", i.e. a stall-less, branch-less, call-less list of less than
a few or less than a few dozens or less than a few hundreds
instructions, the results "findings" in data and corresponding
"matchings" of expressions, that runs in less than one microsecond.
You cannot make the mental translation that if you have:
Ross Finlayson schrieb:
So, the context then is for register state and stack contents, that
the indicators of the above as "positive presence" then is to make
for that the adjustments to the offsets and extents and the shifts
is according to those, otherwise no-ops. Then the idea is that a
As independent logical thread state, that automatically MIMD follosw?
Whats the problem to solve then?
Bye
Hi,
Hurry Rossy Boy, the blue bus is waiting.
There is a quite a hyperbole from here:
Tesla S1070 in 2008
700 Watts , 1 Terra Flop
SOLVE TOMORROW?S PROBLEMS TODAY https://www.azken.com/download/Tesla_DS_S1070_EU.pdf
To here:
Blackwell GPU in 2026
575 Watts, 104.8 Terra Flops ( RTX 5090 )
From Volta To Blackwell https://newsletter.semianalysis.com/p/nvidia-tensor-core-evolution-from-volta-to-blackwell
But somehow the S1070 had already Massively-
Parallel, Many-Core Architecture, and forms
of MIMD, since it had 960 / 240 = 4 cores.
960 scalar processor cores (240 per GPU).
But possibly more resticted inside work
groups, than later NVIDIA Volta ff
architecture with independent thread state.
Bye
Disclaimer: The above is only a very rough
RTX 5090 spec. Its doesn't say what value
format and what vector/matrics ops were
used. Also energy consumption may vary.
Mild Shock schrieb:
Hi,
You are still chewing on SIMD. LoL
Ross Finlayson schrieb:
Then the idea is that any of those can be found and matched in
one "run", i.e. a stall-less, branch-less, call-less list of less than
a few or less than a few dozens or less than a few hundreds
instructions, the results "findings" in data and corresponding
"matchings" of expressions, that runs in less than one microsecond.
You cannot make the mental translation that if you have:
Ross Finlayson schrieb:
So, the context then is for register state and stack contents, that
the indicators of the above as "positive presence" then is to make
for that the adjustments to the offsets and extents and the shifts
is according to those, otherwise no-ops. Then the idea is that a
As independent logical thread state, that automatically MIMD follosw?
Whats the problem to solve then?
Bye
Hi,
Hurry Rossy Boy, the blue bus is waiting.
There is a quite a hyperbole from here:
Tesla S1070 in 2008
700 Watts , 1 Terra Flop
SOLVE TOMORROW?S PROBLEMS TODAY https://www.azken.com/download/Tesla_DS_S1070_EU.pdf
To here:
Blackwell GPU in 2026
575 Watts, 104.8 Terra Flops ( RTX 5090 )
From Volta To Blackwell https://newsletter.semianalysis.com/p/nvidia-tensor-core-evolution-from-volta-to-blackwell
But somehow the S1070 had already Massively-
Parallel, Many-Core Architecture, and forms
of MIMD, since it had 960 / 240 = 4 cores.
960 scalar processor cores (240 per GPU).
But possibly more resticted inside work
groups, than later NVIDIA Volta ff
architecture with independent thread state.
Bye
Disclaimer: The above is only a very rough
RTX 5090 spec. Its doesn't say what value
format and what vector/matrics ops were
used. Also energy consumption may vary.
Mild Shock schrieb:
Hi,
You are still chewing on SIMD. LoL
Ross Finlayson schrieb:
Then the idea is that any of those can be found and matched in
one "run", i.e. a stall-less, branch-less, call-less list of less than
a few or less than a few dozens or less than a few hundreds
instructions, the results "findings" in data and corresponding
"matchings" of expressions, that runs in less than one microsecond.
You cannot make the mental translation that if you have:
Ross Finlayson schrieb:
So, the context then is for register state and stack contents, that
the indicators of the above as "positive presence" then is to make
for that the adjustments to the offsets and extents and the shifts
is according to those, otherwise no-ops. Then the idea is that a
As independent logical thread state, that automatically MIMD follosw?
Whats the problem to solve then?
Bye
Hi,
So what does NUM_SHADERS = 4096 shaders mean here?
11.4 Giga Lips with a Budget Laptop https://github.com/Jean-Luc-Picard-2021/gigabudget
Its only the number of logical threads.
CUDA? TEChNOLOGY UNLOCkS ThE POWER OF TESLA MANY-CORE PROCESSORS
The CUDA C compiler simplifies˙ many-core programming
by enabling code development in a high-level language
and optimizing code to run on systems without knowledge of
how many cores are in the hardware.
CUDA applications automatically take advantage of more
cores or fewer cores in a system, so they can scale from
entry-level notebook GPUs to high end GPUs in technical
workstations˙ and further into racks of GPUs in data
centers. This allows developers to
?code once? and deploy on a range of systems, as well as
scale forward in time as future GPUs deliver more
performance per watt and more cores per processor. The benefit
for software users is the opportunity to boost computing
performance simply by adding GPUs or using their
existing GPUs in new ways. https://www.azken.com/download/Tesla_DS_S1070_EU.pdf
Bye
Mild Shock schrieb:
Hi,
Hurry Rossy Boy, the blue bus is waiting.
There is a quite a hyperbole from here:
Tesla S1070 in 2008
700 Watts , 1 Terra Flop
SOLVE TOMORROW?S PROBLEMS TODAY
https://www.azken.com/download/Tesla_DS_S1070_EU.pdf
To here:
Blackwell GPU in 2026
575 Watts, 104.8 Terra Flops ( RTX 5090 )
˙From Volta To Blackwell
https://newsletter.semianalysis.com/p/nvidia-tensor-core-evolution-from-volta-to-blackwell
But somehow the S1070 had already Massively-
Parallel, Many-Core Architecture, and forms
of MIMD, since it had 960 / 240 = 4 cores.
960 scalar processor cores (240 per GPU).
But possibly more resticted inside work
groups, than later NVIDIA Volta ff
architecture with independent thread state.
Bye
Disclaimer: The above is only a very rough
RTX 5090 spec. Its doesn't say what value
format and what vector/matrics ops were
used. Also energy consumption may vary.
Mild Shock schrieb:
Hi,
You are still chewing on SIMD. LoL
Ross Finlayson schrieb:
Then the idea is that any of those can be found and matched inthan
one "run", i.e. a stall-less, branch-less, call-less list of less
a few or less than a few dozens or less than a few hundreds
instructions, the results "findings" in data and corresponding
"matchings" of expressions, that runs in less than one microsecond.
You cannot make the mental translation that if you have:
Ross Finlayson schrieb:
So, the context then is for register state and stack contents, that
the indicators of the above as "positive presence" then is to make
for that the adjustments to the offsets and extents and the shifts
is according to those, otherwise no-ops. Then the idea is that a
As independent logical thread state, that automatically MIMD follosw?
Whats the problem to solve then?
Bye
On 07/29/2026 08:11 AM, Mild Shock wrote:
Then, of course, the idea that it naturally employs or "saturates"
the processor resources while doing work, in the low-level, yet
also has a direct interpretation in higher-level languages, even "higher-level languages without GOTO", has also that it's faster
in both machine-organized, compiled, and interpreted environments.
Hi,
Because of this parallelism you anyway
need to forget about any arithmetization
of product FSA (finite-state automata).
Just forget it. What modern GPU provide
is a kind of hirarchical viewpoint. You
can have barriers in groups etc..
So you can exercise control over your
mongolian horde of logical threads in
a kind of multilevel schema.
Hi,
So what does NUM_SHADERS = 4096 shaders mean here?
11.4 Giga Lips with a Budget Laptop https://github.com/Jean-Luc-Picard-2021/gigabudget
Its only the number of logical threads.
CUDA? TEChNOLOGY UNLOCkS ThE POWER OF TESLA MANY-CORE PROCESSORS
The CUDA C compiler simplifies many-core programming
by enabling code development in a high-level language
and optimizing code to run on systems without knowledge of
how many cores are in the hardware.
CUDA applications automatically take advantage of more
cores or fewer cores in a system, so they can scale from
entry-level notebook GPUs to high end GPUs in technical
workstations and further into racks of GPUs in data
centers. This allows developers to
?code once? and deploy on a range of systems, as well as
scale forward in time as future GPUs deliver more
performance per watt and more cores per processor. The benefit
for software users is the opportunity to boost computing
performance simply by adding GPUs or using their
existing GPUs in new ways. https://www.azken.com/download/Tesla_DS_S1070_EU.pdf
Bye
Mild Shock schrieb:
Hi,
Hurry Rossy Boy, the blue bus is waiting.
There is a quite a hyperbole from here:
Tesla S1070 in 2008
700 Watts , 1 Terra Flop
SOLVE TOMORROW?S PROBLEMS TODAY
https://www.azken.com/download/Tesla_DS_S1070_EU.pdf
To here:
Blackwell GPU in 2026
575 Watts, 104.8 Terra Flops ( RTX 5090 )
From Volta To Blackwell
https://newsletter.semianalysis.com/p/nvidia-tensor-core-evolution-from-volta-to-blackwell
But somehow the S1070 had already Massively-
Parallel, Many-Core Architecture, and forms
of MIMD, since it had 960 / 240 = 4 cores.
960 scalar processor cores (240 per GPU).
But possibly more resticted inside work
groups, than later NVIDIA Volta ff
architecture with independent thread state.
Bye
Disclaimer: The above is only a very rough
RTX 5090 spec. Its doesn't say what value
format and what vector/matrics ops were
used. Also energy consumption may vary.
Mild Shock schrieb:
Hi,
You are still chewing on SIMD. LoL
Ross Finlayson schrieb:
Then the idea is that any of those can be found and matched inthan
one "run", i.e. a stall-less, branch-less, call-less list of less
a few or less than a few dozens or less than a few hundreds
instructions, the results "findings" in data and corresponding
"matchings" of expressions, that runs in less than one microsecond.
You cannot make the mental translation that if you have:
Ross Finlayson schrieb:
So, the context then is for register state and stack contents, that
the indicators of the above as "positive presence" then is to make
for that the adjustments to the offsets and extents and the shifts
is according to those, otherwise no-ops. Then the idea is that a
As independent logical thread state, that automatically MIMD follosw?
Whats the problem to solve then?
Bye
On 29/07/2026 11:25 PM, Ross Finlayson wrote:
On 07/29/2026 08:11 AM, Mild Shock wrote:
Then, of course, the idea that it naturally employs or "saturates"
the processor resources while doing work, in the low-level, yet
also has a direct interpretation in higher-level languages, even
"higher-level languages without GOTO", has also that it's faster
in both machine-organized, compiled, and interpreted environments.
Didn't you say in some other post you've done Java professionally?
How do you break out of a loop, from within a switch () statement
in Java? I gather that's simply impossible, because "goto" isn't implemented, and the "break" statement doesn't see labels outside
the switch ()?
Not sure how well that fits within comp.theory, as I haven't sub-
scribed yet, but perhaps Mild Shock is willing to comment on that
glaring deficiency in the Java programming language?
On 29/07/2026 11:25 PM, Ross Finlayson wrote:
On 07/29/2026 08:11 AM, Mild Shock wrote:
Then, of course, the idea that it naturally employs or "saturates"
the processor resources while doing work, in the low-level, yet
also has a direct interpretation in higher-level languages, even
"higher-level languages without GOTO", has also that it's faster
in both machine-organized, compiled, and interpreted environments.
Didn't you say in some other post you've done Java professionally?
How do you break out of a loop, from within a switch () statement
in Java?˙ I gather that's simply impossible, because "goto" isn't implemented, and the "break" statement doesn't see labels outside
the switch ()?
Not sure how well that fits within comp.theory, as I haven't sub-
scribed yet, but perhaps Mild Shock is willing to comment on that
glaring deficiency in the Java programming language?
Hi,
Using Java sometimes doesn't make me a Java
evangelist. I wouldn't care less about any
programming language, because the idea of
pi-WAM draws from pi-calculus and WAM. But
since we are in 2026, not many people
might remember pi-calculus:
Functions as Processes
Robin Milner - June 1989
https://hal.science/docs/00/07/54/05/PDF/RR-1154.pdf
AI chat bots know pi-calculus from time to
time, while interacting, they spit out
pi-calculus. I have always to tame them,
and let them cool down, since well, the
pi-calculus doesn't happen directly in the
pi-WAM. Rather in the FFI, which has create
operations on threads and queue, frankly my
pi-WAM is an extremly crippled, has only
a few primitives from pi-calculus.
BYe
Johann 'Myrkraverk' Oskarsson schrieb:
On 29/07/2026 11:25 PM, Ross Finlayson wrote:
On 07/29/2026 08:11 AM, Mild Shock wrote:
Then, of course, the idea that it naturally employs or "saturates"
the processor resources while doing work, in the low-level, yet
also has a direct interpretation in higher-level languages, even
"higher-level languages without GOTO", has also that it's faster
in both machine-organized, compiled, and interpreted environments.
Didn't you say in some other post you've done Java professionally?
How do you break out of a loop, from within a switch () statement
in Java?˙ I gather that's simply impossible, because "goto" isn't
implemented, and the "break" statement doesn't see labels outside
the switch ()?
Not sure how well that fits within comp.theory, as I haven't sub-
scribed yet, but perhaps Mild Shock is willing to comment on that
glaring deficiency in the Java programming language?
Hi,
Using Java sometimes doesn't make me a Java
evangelist. I wouldn't care less about any
programming language, because the idea of
pi-WAM draws from pi-calculus and WAM. But
since we are in 2026, not many people
might remember pi-calculus:
Functions as Processes
Robin Milner - June 1989
https://hal.science/docs/00/07/54/05/PDF/RR-1154.pdf
AI chat bots know pi-calculus from time to
time, while interacting, they spit out
pi-calculus. I have always to tame them,
and let them cool down, since well, the
pi-calculus doesn't happen directly in the
pi-WAM. Rather in the FFI, which has create
operations on threads and queue, frankly my
pi-WAM is an extremly crippled, has only
a few primitives from pi-calculus.
BYe
Johann 'Myrkraverk' Oskarsson schrieb:
On 29/07/2026 11:25 PM, Ross Finlayson wrote:
On 07/29/2026 08:11 AM, Mild Shock wrote:
Then, of course, the idea that it naturally employs or "saturates"
the processor resources while doing work, in the low-level, yet
also has a direct interpretation in higher-level languages, even
"higher-level languages without GOTO", has also that it's faster
in both machine-organized, compiled, and interpreted environments.
Didn't you say in some other post you've done Java professionally?
How do you break out of a loop, from within a switch () statement
in Java? I gather that's simply impossible, because "goto" isn't
implemented, and the "break" statement doesn't see labels outside
the switch ()?
Not sure how well that fits within comp.theory, as I haven't sub-
scribed yet, but perhaps Mild Shock is willing to comment on that
glaring deficiency in the Java programming language?
pi-WAM is compiled to Hack VM. You
can realize goto's wherever you want.
Hi,
You are still chewing on SIMD. LoL
Ross Finlayson schrieb:
Then the idea is that any of those can be found and matched in
one "run", i.e. a stall-less, branch-less, call-less list of less than
a few or less than a few dozens or less than a few hundreds
instructions, the results "findings" in data and corresponding
"matchings" of expressions, that runs in less than one microsecond.
You cannot make the mental translation that if you have:
Ross Finlayson schrieb:
So, the context then is for register state and stack contents, that
the indicators of the above as "positive presence" then is to make
for that the adjustments to the offsets and extents and the shifts
is according to those, otherwise no-ops. Then the idea is that a
As independent logical thread state, that automatically MIMD follosw?
Whats the problem to solve then?
Bye
Hi,
pi-WAM is compiled to Hack VM. You
can realize goto's wherever you want.
In particular the repo contains two versions
of a Hack VM, written in WebGPU / WGSL:
Hack VM: Version 1.0 https://github.com/Jean-Luc-Picard-2021/gigabudget/blob/main/course/example63/boot.mjs
Hack VM: Version 2.0 https://github.com/Jean-Luc-Picard-2021/gigabudget/blob/main/course/example64/boot2.mjs
Version 1.0 is for a single compute shader
expriment. And Version 2.o is for a multi
compute shader experiment.
Bye
Mild Shock schrieb:
Hi,
You are still chewing on SIMD. LoL
Ross Finlayson schrieb:
Then the idea is that any of those can be found and matched in
one "run", i.e. a stall-less, branch-less, call-less list of less than
a few or less than a few dozens or less than a few hundreds
instructions, the results "findings" in data and corresponding
"matchings" of expressions, that runs in less than one microsecond.
You cannot make the mental translation that if you have:
Ross Finlayson schrieb:
So, the context then is for register state and stack contents, that
the indicators of the above as "positive presence" then is to make
for that the adjustments to the offsets and extents and the shifts
is according to those, otherwise no-ops. Then the idea is that a
As independent logical thread state, that automatically MIMD follosw?
Whats the problem to solve then?
Bye
Hi,
With ă-WAM we add a second Prolog VM to the
same Prolog system, with the aim to use
it for specialized tasks:
Emulating ă-WAM in Dogelog Player
https://medium.com/2989/de9cd29c7d37
Optimized for speed the ă-WAM is very primitive.
The compiler capitalizes that code blocks
are relocatable.
Bye
Mild Shock schrieb:
Hi,
pi-WAM is compiled to Hack VM. You
can realize goto's wherever you want.
In particular the repo contains two versions
of a Hack VM, written in WebGPU / WGSL:
Hack VM: Version 1.0
https://github.com/Jean-Luc-Picard-2021/gigabudget/blob/main/course/example63/boot.mjs
Hack VM: Version 2.0
https://github.com/Jean-Luc-Picard-2021/gigabudget/blob/main/course/example64/boot2.mjs
Version 1.0 is for a single compute shader
expriment. And Version 2.o is for a multi
compute shader experiment.
Bye
Mild Shock schrieb:
Hi,
You are still chewing on SIMD. LoL
Ross Finlayson schrieb:
Then the idea is that any of those can be found and matched inthan
one "run", i.e. a stall-less, branch-less, call-less list of less
a few or less than a few dozens or less than a few hundreds
instructions, the results "findings" in data and corresponding
"matchings" of expressions, that runs in less than one microsecond.
You cannot make the mental translation that if you have:
Ross Finlayson schrieb:
So, the context then is for register state and stack contents, that
the indicators of the above as "positive presence" then is to make
for that the adjustments to the offsets and extents and the shifts
is according to those, otherwise no-ops. Then the idea is that a
As independent logical thread state, that automatically MIMD follosw?
Whats the problem to solve then?
Bye
Stupid gangster:˙ teamsters are a union.
In the trades, not the steals, ....
Hi,
Whats wrong with you, your face looks strange.
You look like yellow mustard called Rossy Body.
Are you yealous? Yealous that you cannot program.
Yealous that you are to stupid to cannot build
compilers. Yealous that you cannot unerstand WebGPU.
Yealous that you cannot AI Laptop. Yealous that
you have nothing to sell on usenet?
LoL
Bye
Ross Finlayson schrieb:
Stupid gangster:˙ teamsters are a union.
In the trades, not the steals, ....
.. bla bla goto bla bla ..
Stupid gangster: teamsters are a union.
In the trades, not the steals, ....
On 28/07/2026 2:43 AM, Ross Finlayson wrote:
Hello, here I'll post some design notes and a panel discussion with some
chat-bots about making some sense of the "vector-wide scalar word"
and "character machines", on commodity hardware about ubiquitous
operations.
It's considered at least tangentially relevant to comp.lang.c and
comp.lang.c++ because for example text is ubiquitous and the targets
would be low-level, while the higher-level languages would have a
same sort of patternry, and for example that libc and cstdlib are
standard, and as with regards to POSIX and Unicode and so on.
Please feel free to excuse or ignore, or comment as freely.
Thanks for reading.
Are you generating all of your code via LLMs?˙ Rest assured,
the LLM generated code will have subtle and sometimes not so subtle
bugs.
Happy bughunting!
No, troll, these are serial algorithms their optimized forms.
Normal sorts of forms, ....
Yeah, everybody already figured out "interpreters" and
"programs" and "spawning".
Go spawn yourself.
Hi,
This was archived on Jul 9, 2026:
11.4 Giga Lips with a Budget Laptop https://github.com/Jean-Luc-Picard-2021/gigabudget
Still, Jul 29, Rossy Boy halucinates accusations:
Ross Finlayson schrieb:
.. bla bla goto bla bla ..
Stupid gangster:˙ teamsters are a union.
In the trades, not the steals, ....
Woa! Thats now 20 days of brain desease,
and not understanding the meaning and implications.
Even not understand pi-WAM has Hack VM backend.
But its all opensource. Bravo Rossy Boy, you are
champion in brainlessness and lazyness of
a idiot usenet troll.
Bye
Johann 'Myrkraverk' Oskarsson schrieb:
On 28/07/2026 2:43 AM, Ross Finlayson wrote:
Hello, here I'll post some design notes and a panel discussion with some >>> chat-bots about making some sense of the "vector-wide scalar word"
and "character machines", on commodity hardware about ubiquitous
operations.
It's considered at least tangentially relevant to comp.lang.c and
comp.lang.c++ because for example text is ubiquitous and the targets
would be low-level, while the higher-level languages would have a
same sort of patternry, and for example that libc and cstdlib are
standard, and as with regards to POSIX and Unicode and so on.
Please feel free to excuse or ignore, or comment as freely.
Thanks for reading.
Are you generating all of your code via LLMs?˙ Rest assured,
the LLM generated code will have subtle and sometimes not so subtle
bugs.
Happy bughunting!
Hi,
Rossy Boys tears could cool a data center,
he thinks there exists no literature about
serial algorithms of parallel stuff, and
he also thinks normal forms lead to optimizing
something. LoL, what a utter bullshit. I did
alreay a serial implementation of a parallel
simulation of my pi-WAM. Just lookup the literature
about pi-calulus. I published it a few days ago,
its part of 2.2.4 released already:
Parallel ă-WAM: An Interleaved Synchronous Emulator https://medium.com/2989/0196089e143a
Whats your point, Rossy Boy? Except you post pretend
nonsense not knowing what you are doing?
Bye
Ross Finlayson schrieb:
No, troll, these are serial algorithms their optimized forms.
Normal sorts of forms, ....
Yeah, everybody already figured out "interpreters" and
"programs" and "spawning".
Go spawn yourself.
Mild Shock schrieb:
Hi,
This was archived on Jul 9, 2026:
11.4 Giga Lips with a Budget Laptop
https://github.com/Jean-Luc-Picard-2021/gigabudget
Still, Jul 29, Rossy Boy halucinates accusations:
Ross Finlayson schrieb:
.. bla bla goto bla bla ..
Stupid gangster: teamsters are a union.
In the trades, not the steals, ....
Woa! Thats now 20 days of brain desease,
and not understanding the meaning and implications.
Even not understand pi-WAM has Hack VM backend.
But its all opensource. Bravo Rossy Boy, you are
champion in brainlessness and lazyness of
a idiot usenet troll.
Bye
Johann 'Myrkraverk' Oskarsson schrieb:
On 28/07/2026 2:43 AM, Ross Finlayson wrote:
Hello, here I'll post some design notes and a panel discussion with
some
chat-bots about making some sense of the "vector-wide scalar word"
and "character machines", on commodity hardware about ubiquitous
operations.
It's considered at least tangentially relevant to comp.lang.c and
comp.lang.c++ because for example text is ubiquitous and the targets
would be low-level, while the higher-level languages would have a
same sort of patternry, and for example that libc and cstdlib are
standard, and as with regards to POSIX and Unicode and so on.
Please feel free to excuse or ignore, or comment as freely.
Thanks for reading.
Are you generating all of your code via LLMs? Rest assured,
the LLM generated code will have subtle and sometimes not so subtle
bugs.
Happy bughunting!
https://www.theregister.com/databases/2026/07/29/after-rewriting-sqlite-in-rust-turso-turns-its-sights-on-postgres/5279835
I don't much care about Rust.
.. gibberish ..
Thief.
https://www.theregister.com/databases/2026/07/29/after-rewriting-sqlite- in-rust-turso-turns-its-sights-on-postgres/5279835
I don't much care about Rust. It's yet another Google product,
with the idea of not having exception handling, then supposedly
it's efficient and safe, yet, it's efficient by not being safe,
and safe by not being efficient. Then there's the macro/metaprogramming front-end, which basically doesn't validate
like templates or otherwise for compile-time invariants,
that is basically like people who use string substititution instead
of object models, who all suffer injection attacks.
This latest manic episode has that in some more clinical or caring
settings, then one might wonder over the author's need to get help
or whether they're lost their mittens. In another view, though,
that's crazy-town and it's not a good place and we don't go there
any-more, population burse-scheiss-bots. Anyways here we just
generally respect people well enough to let them well alone.
Not to spring on you that you're wrong, it's not a conspiracy
against you, anyways as per the usual Shut Up goes out to any
of these JB, JG, PO, WM, ..., sock-puppet bots.
Thief.
On 30/07/2026 2:13 AM, Ross Finlayson wrote:
https://www.theregister.com/databases/2026/07/29/after-rewriting-sqlite-
in-rust-turso-turns-its-sights-on-postgres/5279835
I don't much care about Rust. It's yet another Google product,
with the idea of not having exception handling, then supposedly
it's efficient and safe, yet, it's efficient by not being safe,
and safe by not being efficient. Then there's the macro/metaprogramming
front-end, which basically doesn't validate
like templates or otherwise for compile-time invariants,
that is basically like people who use string substititution instead
of object models, who all suffer injection attacks.
Personally, I like Postgres in C, and I hope it stays there. I used to maintain PL/Java, and got intimately familiar with some of the limi-
tations of the JNI interface. And while there's some new Java foreign function interface now, it doesn't replace JNI. Especially for projects
that embed the JVM like PL/Java.
I haven't contributed to that project for maybe one and half decade, and
now that I'm using Java again -- a project I'll mention in another
thread --[1] I may just resume some duties in PL/Java. But that's a
future adventure that may or may not happen.
So, I was going to say something about Postgres? Right, I'm sure the
author of Postgres-in-Rust will run into some of the problems people
always run into when they attempt to rewrite other large projects, and
that's not learning from the prior mistakes. I try to avoid that.
Some of that I learned the hard way, and some of that I learned by read-
ing the /Mythical Man Month/. I don't remember the author's name, and
my physical copy is not in my current library, but I believe the author
is famous enough I don't need to mention him by name.
This latest manic episode has that in some more clinical or caring
settings, then one might wonder over the author's need to get help
or whether they're lost their mittens. In another view, though,
that's crazy-town and it's not a good place and we don't go there
any-more, population burse-scheiss-bots. Anyways here we just
generally respect people well enough to let them well alone.
I don't remote diagnose people. While I don't have a medical license
to lose, I feel it's impolite to potentially mis-diagnose people over
text messages.
I have not felt very respected here in comp.lang.c. I guess we must
have some different experiences in this place. Who exactly is
welcoming, and a warm person?
Not to spring on you that you're wrong, it's not a conspiracy
against you, anyways as per the usual Shut Up goes out to any
of these JB, JG, PO, WM, ..., sock-puppet bots.
I'm not sure I recognize all of these initials. I'm sure I'll
learn to not engage with the problem children here in comp.lang.c,
but it's been a few days, and I'm still familiarizing myself with
the regulars.
Thief.
Who exactly is the thief? Does this person have stats in the Rogue
class in dungeons and dragons?
Happy C coding!
[1] Those pretend em-dashes will surely make Dan Cross even more
fictional. I hope his rage isn't fictional and he'll byte every
character I type here in comp.lang.c.
Who exactly is the thief? Does this person
have stats in the Rogue class in dungeons
and dragons?
On 30/07/2026 2:13 AM, Ross Finlayson wrote:
https://www.theregister.com/databases/2026/07/29/after-rewriting-sqlite-
in-rust-turso-turns-its-sights-on-postgres/5279835
I don't much care about Rust. It's yet another Google product,
with the idea of not having exception handling, then supposedly
it's efficient and safe, yet, it's efficient by not being safe,
and safe by not being efficient. Then there's the macro/metaprogramming
front-end, which basically doesn't validate
like templates or otherwise for compile-time invariants,
that is basically like people who use string substititution instead
of object models, who all suffer injection attacks.
Personally, I like Postgres in C, and I hope it stays there.˙ I used to maintain PL/Java, and got intimately familiar with some of the limi-
tations of the JNI interface.˙ And while there's some new Java foreign function interface now, it doesn't replace JNI.˙ Especially for projects
that embed the JVM like PL/Java.
I haven't contributed to that project for maybe one and half decade, and
now that I'm using Java again -- a project I'll mention in another
thread --[1] I may just resume some duties in PL/Java.˙ But that's a
future adventure that may or may not happen.
So, I was going to say something about Postgres?˙ Right, I'm sure the
author of Postgres-in-Rust will run into some of the problems people
always run into when they attempt to rewrite other large projects, and
that's not learning from the prior mistakes.˙ I try to avoid that.
Some of that I learned the hard way, and some of that I learned by read-
ing the /Mythical Man Month/.˙ I don't remember the author's name, and
my physical copy is not in my current library, but I believe the author
is famous enough I don't need to mention him by name.
This latest manic episode has that in some more clinical or caring
settings, then one might wonder over the author's need to get help
or whether they're lost their mittens. In another view, though,
that's crazy-town and it's not a good place and we don't go there
any-more, population burse-scheiss-bots. Anyways here we just
generally respect people well enough to let them well alone.
I don't remote diagnose people.˙ While I don't have a medical license
to lose, I feel it's impolite to potentially mis-diagnose people over
text messages.
I have not felt very respected here in comp.lang.c.˙ I guess we must
have some different experiences in this place.˙ Who exactly is
welcoming, and a warm person?
Not to spring on you that you're wrong, it's not a conspiracy
against you, anyways as per the usual Shut Up goes out to any
of these JB, JG, PO, WM, ..., sock-puppet bots.
I'm not sure I recognize all of these initials.˙ I'm sure I'll
learn to not engage with the problem children here in comp.lang.c,
but it's been a few days, and I'm still familiarizing myself with
the regulars.
Thief.
Who exactly is the thief?˙ Does this person have stats in the Rogue
class in dungeons and dragons?
Happy C coding!
[1] Those pretend em-dashes will surely make Dan Cross even more
fictional.˙ I hope his rage isn't fictional and he'll byte every
character I type here in comp.lang.c.
On 07/29/2026 12:46 PM, Johann 'Myrkraverk' Oskarsson wrote:
On 30/07/2026 2:13 AM, Ross Finlayson wrote:
https://www.theregister.com/databases/2026/07/29/after-rewriting-sqlite- >>> in-rust-turso-turns-its-sights-on-postgres/5279835
I don't much care about Rust. It's yet another Google product,
with the idea of not having exception handling, then supposedly
it's efficient and safe, yet, it's efficient by not being safe,
and safe by not being efficient. Then there's the macro/metaprogramming
front-end, which basically doesn't validate
like templates or otherwise for compile-time invariants,
that is basically like people who use string substititution instead
of object models, who all suffer injection attacks.
Personally, I like Postgres in C, and I hope it stays there.˙ I used to
maintain PL/Java, and got intimately familiar with some of the limi-
tations of the JNI interface.˙ And while there's some new Java foreign
function interface now, it doesn't replace JNI.˙ Especially for projects
that embed the JVM like PL/Java.
I haven't contributed to that project for maybe one and half decade, and
now that I'm using Java again -- a project I'll mention in another
thread --[1] I may just resume some duties in PL/Java.˙ But that's a
future adventure that may or may not happen.
So, I was going to say something about Postgres?˙ Right, I'm sure the
author of Postgres-in-Rust will run into some of the problems people
always run into when they attempt to rewrite other large projects, and
that's not learning from the prior mistakes.˙ I try to avoid that.
Some of that I learned the hard way, and some of that I learned by read-
ing the /Mythical Man Month/.˙ I don't remember the author's name, and
my physical copy is not in my current library, but I believe the author
is famous enough I don't need to mention him by name.
This latest manic episode has that in some more clinical or caring
settings, then one might wonder over the author's need to get help
or whether they're lost their mittens. In another view, though,
that's crazy-town and it's not a good place and we don't go there
any-more, population burse-scheiss-bots. Anyways here we just
generally respect people well enough to let them well alone.
I don't remote diagnose people.˙ While I don't have a medical license
to lose, I feel it's impolite to potentially mis-diagnose people over
text messages.
I have not felt very respected here in comp.lang.c.˙ I guess we must
have some different experiences in this place.˙ Who exactly is
welcoming, and a warm person?
Not to spring on you that you're wrong, it's not a conspiracy
against you, anyways as per the usual Shut Up goes out to any
of these JB, JG, PO, WM, ..., sock-puppet bots.
I'm not sure I recognize all of these initials.˙ I'm sure I'll
learn to not engage with the problem children here in comp.lang.c,
but it's been a few days, and I'm still familiarizing myself with
the regulars.
Thief.
Who exactly is the thief?˙ Does this person have stats in the Rogue
class in dungeons and dragons?
Happy C coding!
[1] Those pretend em-dashes will surely make Dan Cross even more
fictional.˙ I hope his rage isn't fictional and he'll byte every
character I type here in comp.lang.c.
Thanks for writing. Good luck with that.
Now, if we attain to some decorum, that would be refreshing.
I "know" Java and am familiar with C/C++, and computer engineering.
Then, here the "Viswath & Charmaigne" is for the idea that there
are generous, usual sorts of algorithms, here "findings" and
"matchings", that can be implemented vector-wise scalar-word,
then that for things like: libc, POSIX tools, parsers, and
so on, or as among "text-utils", and for character handling,
that much like many of the distributions like Linux, FreeBSD,
and so on, have developed and released and made in their tree
the vectorized versions of string functions, that, there are
abstract models of regular "text algos" that make sense for
all modern commodity architectures in their default configuration,
for the system libraries and default toolset. For example, most
all of "text-utils" involves "findings" and "matchings", in a sense,
then as with regards to "sorting" and "translation" or "transformation", which is not addressed.
The mentioned initialisms are, or were, awful sci.math trolls.
Good times, ....
On 07/29/2026 12:46 PM, Johann 'Myrkraverk' Oskarsson wrote:
On 30/07/2026 2:13 AM, Ross Finlayson wrote:
https://www.theregister.com/databases/2026/07/29/after-rewriting-sqlite- >>> in-rust-turso-turns-its-sights-on-postgres/5279835
I don't much care about Rust. It's yet another Google product,
with the idea of not having exception handling, then supposedly
it's efficient and safe, yet, it's efficient by not being safe,
and safe by not being efficient. Then there's the macro/metaprogramming
front-end, which basically doesn't validate
like templates or otherwise for compile-time invariants,
that is basically like people who use string substititution instead
of object models, who all suffer injection attacks.
Personally, I like Postgres in C, and I hope it stays there.˙ I used to
maintain PL/Java, and got intimately familiar with some of the limi-
tations of the JNI interface.˙ And while there's some new Java foreign
function interface now, it doesn't replace JNI.˙ Especially for projects
that embed the JVM like PL/Java.
I haven't contributed to that project for maybe one and half decade, and
now that I'm using Java again -- a project I'll mention in another
thread --[1] I may just resume some duties in PL/Java.˙ But that's a
future adventure that may or may not happen.
So, I was going to say something about Postgres?˙ Right, I'm sure the
author of Postgres-in-Rust will run into some of the problems people
always run into when they attempt to rewrite other large projects, and
that's not learning from the prior mistakes.˙ I try to avoid that.
Some of that I learned the hard way, and some of that I learned by read-
ing the /Mythical Man Month/.˙ I don't remember the author's name, and
my physical copy is not in my current library, but I believe the author
is famous enough I don't need to mention him by name.
This latest manic episode has that in some more clinical or caring
settings, then one might wonder over the author's need to get help
or whether they're lost their mittens. In another view, though,
that's crazy-town and it's not a good place and we don't go there
any-more, population burse-scheiss-bots. Anyways here we just
generally respect people well enough to let them well alone.
I don't remote diagnose people.˙ While I don't have a medical license
to lose, I feel it's impolite to potentially mis-diagnose people over
text messages.
I have not felt very respected here in comp.lang.c.˙ I guess we must
have some different experiences in this place.˙ Who exactly is
welcoming, and a warm person?
Not to spring on you that you're wrong, it's not a conspiracy
against you, anyways as per the usual Shut Up goes out to any
of these JB, JG, PO, WM, ..., sock-puppet bots.
I'm not sure I recognize all of these initials.˙ I'm sure I'll
learn to not engage with the problem children here in comp.lang.c,
but it's been a few days, and I'm still familiarizing myself with
the regulars.
Thief.
Who exactly is the thief?˙ Does this person have stats in the Rogue
class in dungeons and dragons?
Happy C coding!
[1] Those pretend em-dashes will surely make Dan Cross even more
fictional.˙ I hope his rage isn't fictional and he'll byte every
character I type here in comp.lang.c.
Thanks for writing. Good luck with that.
Now, if we attain to some decorum, that would be refreshing.
I "know" Java and am familiar with C/C++, and computer engineering.
Then, here the "Viswath & Charmaigne" is for the idea that there
are generous, usual sorts of algorithms, here "findings" and
"matchings", that can be implemented vector-wise scalar-word,
then that for things like: libc, POSIX tools, parsers, and
so on, or as among "text-utils", and for character handling,
that much like many of the distributions like Linux, FreeBSD,
and so on, have developed and released and made in their tree
the vectorized versions of string functions, that, there are
abstract models of regular "text algos" that make sense for
all modern commodity architectures in their default configuration,
for the system libraries and default toolset. For example, most
all of "text-utils" involves "findings" and "matchings", in a sense,
then as with regards to "sorting" and "translation" or "transformation", which is not addressed.
The mentioned initialisms are, or were, awful sci.math trolls.
Good times, ....
Hi,
Who exactly is the thief? Does this person
have stats in the Rogue class in dungeons
and dragons?
The conspiracy theory of a stealing of Torso VDBE,
by Rossy Boy, is probably a result of complete
ignorance of the Hack ecosystem.
Hack is a very popular computer science project,
with a couple of subprojects in hardware and
software. It goes also by the name Nand to Tetris,
and is programming language agnositic. You can do
Hack experiments in any programming language, be
it BASIC, ADA or Rust. Nobody cares.
The gist are projects like here, first to
educate yourself about Hack:
https://www.nand2tetris.org/course
And then to use Hack in different contexts:
https://www.nand2tetris.org/copy-of-talks
For didactic purposes, I used Hack for my WebGPU
experiment. I didn't even take a look at Torso
VDBE, why should I? Hack is nicely documented,
has even a book, and fusing the two 16-bit
instruction types A and D, into a single 32-bit
instruction stream, is nowhere patented.
Bye
Johann 'Myrkraverk' Oskarsson schrieb:
On 30/07/2026 2:13 AM, Ross Finlayson wrote:
https://www.theregister.com/databases/2026/07/29/after-rewriting-sqlite- >>> in-rust-turso-turns-its-sights-on-postgres/5279835
I don't much care about Rust. It's yet another Google product,
with the idea of not having exception handling, then supposedly
it's efficient and safe, yet, it's efficient by not being safe,
and safe by not being efficient. Then there's the macro/metaprogramming
front-end, which basically doesn't validate
like templates or otherwise for compile-time invariants,
that is basically like people who use string substititution instead
of object models, who all suffer injection attacks.
Personally, I like Postgres in C, and I hope it stays there.˙ I used to
maintain PL/Java, and got intimately familiar with some of the limi-
tations of the JNI interface.˙ And while there's some new Java foreign
function interface now, it doesn't replace JNI.˙ Especially for projects
that embed the JVM like PL/Java.
I haven't contributed to that project for maybe one and half decade, and
now that I'm using Java again -- a project I'll mention in another
thread --[1] I may just resume some duties in PL/Java.˙ But that's a
future adventure that may or may not happen.
So, I was going to say something about Postgres?˙ Right, I'm sure the
author of Postgres-in-Rust will run into some of the problems people
always run into when they attempt to rewrite other large projects, and
that's not learning from the prior mistakes.˙ I try to avoid that.
Some of that I learned the hard way, and some of that I learned by read-
ing the /Mythical Man Month/.˙ I don't remember the author's name, and
my physical copy is not in my current library, but I believe the author
is famous enough I don't need to mention him by name.
This latest manic episode has that in some more clinical or caring
settings, then one might wonder over the author's need to get help
or whether they're lost their mittens. In another view, though,
that's crazy-town and it's not a good place and we don't go there
any-more, population burse-scheiss-bots. Anyways here we just
generally respect people well enough to let them well alone.
I don't remote diagnose people.˙ While I don't have a medical license
to lose, I feel it's impolite to potentially mis-diagnose people over
text messages.
I have not felt very respected here in comp.lang.c.˙ I guess we must
have some different experiences in this place.˙ Who exactly is
welcoming, and a warm person?
Not to spring on you that you're wrong, it's not a conspiracy
against you, anyways as per the usual Shut Up goes out to any
of these JB, JG, PO, WM, ..., sock-puppet bots.
I'm not sure I recognize all of these initials.˙ I'm sure I'll
learn to not engage with the problem children here in comp.lang.c,
but it's been a few days, and I'm still familiarizing myself with
the regulars.
Thief.
Who exactly is the thief?˙ Does this person have stats in the Rogue
class in dungeons and dragons?
Happy C coding!
[1] Those pretend em-dashes will surely make Dan Cross even more
fictional.˙ I hope his rage isn't fictional and he'll byte every
character I type here in comp.lang.c.
On 29/07/2026 5:15 PM, Mild Shock wrote:
Hi,
Confused rossy boy is confused. We are
not building a stupid web server, where
a listener thread spawns service threads,
and to avoid malloc and free, reuses
a pool, or some shitty fork join framework.
The producer and consumer example I posted
elsewhere archived a dataflow without
malloc and free of threads. You are miles
away from what we are doing here.
Why not?˙ Isn't this comp.lang.c?˙ And isn't that exactly how
CivetWeb works internally?
Have you never built your own web
sever in C?˙ Not even with CivetWeb?˙ It's really easy!˙ You
only need to implement a callback or two.
Hi,
This seems to be a funny Q16.16 experiment.
It shows that an integerish Hack can do
floatish stuff, by using binary fixpoint:
Raytracing on the Hack computer
2021/06/13 - im alex
https://blog.alexqua.ch/posts/from-nand-to-raytracer/
That it uses Rust is arbitrary. Feel free
to do it in C, C++, FORTRAN or Java. I guess
these languages all have basic arithmethic,
right? Maybe not a long jump always?
Bye
Mild Shock schrieb:
Hi,
Who exactly is the thief? Does this person
have stats in the Rogue class in dungeons
and dragons?
The conspiracy theory of a stealing of Torso VDBE,
by Rossy Boy, is probably a result of complete
ignorance of the Hack ecosystem.
Hack is a very popular computer science project,
with a couple of subprojects in hardware and
software. It goes also by the name Nand to Tetris,
and is programming language agnositic. You can do
Hack experiments in any programming language, be
it BASIC, ADA or Rust. Nobody cares.
The gist are projects like here, first to
educate yourself about Hack:
https://www.nand2tetris.org/course
And then to use Hack in different contexts:
https://www.nand2tetris.org/copy-of-talks
For didactic purposes, I used Hack for my WebGPU
experiment. I didn't even take a look at Torso
VDBE, why should I? Hack is nicely documented,
has even a book, and fusing the two 16-bit
instruction types A and D, into a single 32-bit
instruction stream, is nowhere patented.
Bye
Johann 'Myrkraverk' Oskarsson schrieb:
On 30/07/2026 2:13 AM, Ross Finlayson wrote:
https://www.theregister.com/databases/2026/07/29/after-rewriting-sqlite- >>>> in-rust-turso-turns-its-sights-on-postgres/5279835
I don't much care about Rust. It's yet another Google product,
with the idea of not having exception handling, then supposedly
it's efficient and safe, yet, it's efficient by not being safe,
and safe by not being efficient. Then there's the macro/metaprogramming >>>> front-end, which basically doesn't validate
like templates or otherwise for compile-time invariants,
that is basically like people who use string substititution instead
of object models, who all suffer injection attacks.
Personally, I like Postgres in C, and I hope it stays there.˙ I used to
maintain PL/Java, and got intimately familiar with some of the limi-
tations of the JNI interface.˙ And while there's some new Java foreign
function interface now, it doesn't replace JNI.˙ Especially for projects >>> that embed the JVM like PL/Java.
I haven't contributed to that project for maybe one and half decade, and >>> now that I'm using Java again -- a project I'll mention in another
thread --[1] I may just resume some duties in PL/Java.˙ But that's a
future adventure that may or may not happen.
So, I was going to say something about Postgres?˙ Right, I'm sure the
author of Postgres-in-Rust will run into some of the problems people
always run into when they attempt to rewrite other large projects, and
that's not learning from the prior mistakes.˙ I try to avoid that.
Some of that I learned the hard way, and some of that I learned by read- >>> ing the /Mythical Man Month/.˙ I don't remember the author's name, and
my physical copy is not in my current library, but I believe the author
is famous enough I don't need to mention him by name.
This latest manic episode has that in some more clinical or caring
settings, then one might wonder over the author's need to get help
or whether they're lost their mittens. In another view, though,
that's crazy-town and it's not a good place and we don't go there
any-more, population burse-scheiss-bots. Anyways here we just
generally respect people well enough to let them well alone.
I don't remote diagnose people.˙ While I don't have a medical license
to lose, I feel it's impolite to potentially mis-diagnose people over
text messages.
I have not felt very respected here in comp.lang.c.˙ I guess we must
have some different experiences in this place.˙ Who exactly is
welcoming, and a warm person?
Not to spring on you that you're wrong, it's not a conspiracy
against you, anyways as per the usual Shut Up goes out to any
of these JB, JG, PO, WM, ..., sock-puppet bots.
I'm not sure I recognize all of these initials.˙ I'm sure I'll
learn to not engage with the problem children here in comp.lang.c,
but it's been a few days, and I'm still familiarizing myself with
the regulars.
Thief.
Who exactly is the thief?˙ Does this person have stats in the Rogue
class in dungeons and dragons?
Happy C coding!
[1] Those pretend em-dashes will surely make Dan Cross even more
fictional.˙ I hope his rage isn't fictional and he'll byte every
character I type here in comp.lang.c.
Hi,
You, Johann 'Myrkraverk' Oskarsson, you seem
to arbitrarily add newsgroups to each of your
post. For comp.lang.fortran and now comp.lang.java.
Does this make sense? My news provider doesn't
allow more than 3 cross positings.
Also my Hack
and my GPU experiment has nothing to do with a
particular language. The GPU hardware exists
independent of a hardware, same Hack which has
a abstract VM definition. The same for WAM,
its an acronym for Warren Abstract Machine:
In 1983, David H. D. Warren designed an abstract
machine for the execution of Prolog consisting
of a memory architecture and an instruction set https://en.wikipedia.org/wiki/Warren_Abstract_Machine
You can view Hack primarily as a abstract Machine
first, although I don't know whether this phrase
has still a meaning nowadays. Rossy Boy claimed
to know terms such as interpreter, etc.. But then
he is also mumbling about "text-utils". Well, well,
... there is a lot to learn.
On 30/07/2026 5:00 AM, Mild Shock wrote:
Hi,
You, Johann 'Myrkraverk' Oskarsson, you seem
to arbitrarily add newsgroups to each of your
post. For comp.lang.fortran and now comp.lang.java.
Does this make sense? My news provider doesn't
allow more than 3 cross positings.
It makes a lot of sense from my perspective, and my newsprovider doesn't mind, as you've seen.˙ I don't have issues with other newsproviders, so
I'll endeavor [1] to limit my cross postings,
at least when replying to
you.
˙ This
is different from /Digital Mars/ the compiler.˙ And neither have any connection to Digital, formerly of VAX and OpenVMS fame.
Thanks for writing. Good luck with that.
Now, if we attain to some decorum, that would be refreshing.
I "know" Java and am familiar with C/C++, and computer engineering.
Then, here the "Viswath & Charmaigne" is for the idea that there
are generous, usual sorts of algorithms, here "findings" and
"matchings", that can be implemented vector-wise scalar-word,
then that for things like: libc, POSIX tools, parsers, and
so on, or as among "text-utils", and for character handling,
that much like many of the distributions like Linux, FreeBSD,
and so on, have developed and released and made in their tree
the vectorized versions of string functions, that, there are
abstract models of regular "text algos" that make sense for
all modern commodity architectures in their default configuration,
for the system libraries and default toolset. For example, most
all of "text-utils" involves "findings" and "matchings", in a sense,
then as with regards to "sorting" and "translation" or "transformation", which is not addressed.
The mentioned initialisms are, or were, awful sci.math trolls.
Hi,
Who exactly is the thief? Does this person
have stats in the Rogue class in dungeons
and dragons?
The conspiracy theory of a stealing of Torso VDBE,
by Rossy Boy, is probably a result of complete
ignorance of the Hack ecosystem.
Hack is a very popular computer science project,
with a couple of subprojects in hardware and
software. It goes also by the name Nand to Tetris,
and is programming language agnositic. You can do
Hack experiments in any programming language, be
it BASIC, ADA or Rust. Nobody cares.
The gist are projects like here, first to
educate yourself about Hack:
https://www.nand2tetris.org/course
And then to use Hack in different contexts:
https://www.nand2tetris.org/copy-of-talks
For didactic purposes, I used Hack for my WebGPU
experiment. I didn't even take a look at Torso
VDBE, why should I? Hack is nicely documented,
has even a book, and fusing the two 16-bit
instruction types A and D, into a single 32-bit
instruction stream, is nowhere patented.
Johann 'Myrkraverk' Oskarsson skrev: |-------------------------------------------------------------|
|"I have not felt very respected here in comp.lang.c. [. . .]"| |-------------------------------------------------------------|
Hej!
I am sorry that you feel so! I find you to be helpful!
On 07/27/2026 11:44 AM, Ross Finlayson wrote:
On 07/27/2026 11:43 AM, Ross Finlayson wrote:
Hello, here I'll post some design notes and a panel discussion with some >>> chat-bots about making some sense of the "vector-wide scalar word"
and "character machines", on commodity hardware about ubiquitous
operations.
It's considered at least tangentially relevant to comp.lang.c and
comp.lang.c++ because for example text is ubiquitous and the targets
would be low-level, while the higher-level languages would have a
same sort of patternry, and for example that libc and cstdlib are
standard, and as with regards to POSIX and Unicode and so on.
Please feel free to excuse or ignore, or comment as freely.
Thanks for reading.
[ viswath-charmaigne.txt ]
On 30/07/2026 4:47 AM, Ross Finlayson wrote:
Thanks for writing. Good luck with that.
Now, if we attain to some decorum, that would be refreshing.
Yes, that indeed would be refreshing. I'll refresh myself with some Pepsi before continuing this followup, hold on.
I "know" Java and am familiar with C/C++, and computer engineering.
I just claim I know nothing, and do things anyway. I didn't know how
to parse the Intel Hex file format, before I added a "binary" loader
to the Mars MIPS emulator. You know, the one written in Java.
It's not finished, but I have the basics down, and should be able to
load and run "binaries" with it soon. I'll probably post screenshots
and they'll be hosted on Dropbox, so some of the other regulars won't
look. That's on them.
Then, here the "Viswath & Charmaigne" is for the idea that there
are generous, usual sorts of algorithms, here "findings" and
"matchings", that can be implemented vector-wise scalar-word,
then that for things like: libc, POSIX tools, parsers, and
so on, or as among "text-utils", and for character handling,
that much like many of the distributions like Linux, FreeBSD,
and so on, have developed and released and made in their tree
the vectorized versions of string functions, that, there are
abstract models of regular "text algos" that make sense for
all modern commodity architectures in their default configuration,
for the system libraries and default toolset. For example, most
all of "text-utils" involves "findings" and "matchings", in a sense,
then as with regards to "sorting" and "translation" or "transformation",
which is not addressed.
So I gather you're interested in algorithms that "parallel" with SIMD
and other vector machinery? And you mention "text-utils." Have you
read /String Algorithms in C/ by Mailund? He goes into the nitty gritty details of string matching -- and you can trivially translate the code
to any other programming language as you learn from the book -- in the context of DNA matching. At least that's how I remember the book. The /about the author/ blurb at the start mentions he's a professor of bio- informatics so that seems like a true memory. I'll want to read the
book again soon.
In any case, there are algorithms, string search amongst them, that seem eminently serial, and I'm not quite sure SIMD and related extensions are immediately applicable. And now I'm sure there are people -- and LLMs
-- just itching to "correct me" about that. Let them, they don't bother
me.
The mentioned initialisms are, or were, awful sci.math trolls.
In the mean time, I've gathered a few names here in comp.lang.c that I'll probably never reply to ever again. They know who they are.
On 07/27/2026 11:45 AM, Ross Finlayson wrote:
On 07/27/2026 11:44 AM, Ross Finlayson wrote:
On 07/27/2026 11:43 AM, Ross Finlayson wrote:
Hello, here I'll post some design notes and a panel discussion with
some
chat-bots about making some sense of the "vector-wide scalar word"
and "character machines", on commodity hardware about ubiquitous
operations.
It's considered at least tangentially relevant to comp.lang.c and
comp.lang.c++ because for example text is ubiquitous and the targets
would be low-level, while the higher-level languages would have a
same sort of patternry, and for example that libc and cstdlib are
standard, and as with regards to POSIX and Unicode and so on.
Please feel free to excuse or ignore, or comment as freely.
Thanks for reading.
[ viswath-charmaigne.txt ]
union A, B = A || B / intersection A, B = A && B / setminus A \ B =&& !B
A
Afore-Input: Start-of-Input... Afore-Stitch: at the beginning of aword... After-Split: at the end of a word... After-Input: End-of-Input...
afore-stitch: ...a: start of buffer, before stitch / before-split:...b: end of buffer, before split / after-split: ...a: start of buffer,
On 07/30/2026 06:20 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 30/07/2026 4:47 AM, Ross Finlayson wrote:
Thanks for writing. Good luck with that.
Now, if we attain to some decorum, that would be refreshing.
Yes, that indeed would be refreshing. I'll refresh myself with some
Pepsi
before continuing this followup, hold on.
I "know" Java and am familiar with C/C++, and computer engineering.
I just claim I know nothing, and do things anyway. I didn't know how
to parse the Intel Hex file format, before I added a "binary" loader
to the Mars MIPS emulator. You know, the one written in Java.
It's not finished, but I have the basics down, and should be able to
load and run "binaries" with it soon. I'll probably post screenshots
and they'll be hosted on Dropbox, so some of the other regulars won't
look. That's on them.
Then, here the "Viswath & Charmaigne" is for the idea that there
are generous, usual sorts of algorithms, here "findings" and
"matchings", that can be implemented vector-wise scalar-word,
then that for things like: libc, POSIX tools, parsers, and
so on, or as among "text-utils", and for character handling,
that much like many of the distributions like Linux, FreeBSD,
and so on, have developed and released and made in their tree
the vectorized versions of string functions, that, there are
abstract models of regular "text algos" that make sense for
all modern commodity architectures in their default configuration,
for the system libraries and default toolset. For example, most
all of "text-utils" involves "findings" and "matchings", in a sense,
then as with regards to "sorting" and "translation" or "transformation", >>> which is not addressed.
So I gather you're interested in algorithms that "parallel" with SIMD
and other vector machinery? And you mention "text-utils." Have you
read /String Algorithms in C/ by Mailund? He goes into the nitty gritty
details of string matching -- and you can trivially translate the code
to any other programming language as you learn from the book -- in the
context of DNA matching. At least that's how I remember the book. The
/about the author/ blurb at the start mentions he's a professor of bio-
informatics so that seems like a true memory. I'll want to read the
book again soon.
In any case, there are algorithms, string search amongst them, that seem
eminently serial, and I'm not quite sure SIMD and related extensions are
immediately applicable. And now I'm sure there are people -- and LLMs
-- just itching to "correct me" about that. Let them, they don't bother
me.
The mentioned initialisms are, or were, awful sci.math trolls.
In the mean time, I've gathered a few names here in comp.lang.c that I'll
probably never reply to ever again. They know who they are.
Thanks for the book reference, I'll look to it.
Decades ago when at the university I had a job working
for the biology department and what it was was making a graphical
front-end in Java to launch BLAST gene-sequence search on what
had as about 48 units / 96 cores Sun Silicon Grid Engine MPI cluster,
of Apple pizza boxes with PowerPC cores, then that also I wrote some
code for matching sequences with splitting the input and running the
cluster on the input files and chewing that up, sequences of human DNA
about 9 gigabytes, "seq-reader".
I made a simple dialog with making the command line arguments
for BLAST to launch, then added a features to increase or decrease
the font, that really blew their mind, these days it's often found
with "Shift-plus and Shift-minus".
Java's my main, if I know anything, that's what I know.
On 30/07/2026 5:00 AM, Mild Shock wrote:
Does this make sense? My news provider doesn't
allow more than 3 cross positings.
It makes a lot of sense from my perspective,
On 07/30/2026 06:20 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 30/07/2026 4:47 AM, Ross Finlayson wrote:
Thanks for writing. Good luck with that.
Now, if we attain to some decorum, that would be refreshing.
Yes, that indeed would be refreshing.˙ I'll refresh myself with some
Pepsi
before continuing this followup, hold on.
I "know" Java and am familiar with C/C++, and computer engineering.
I just claim I know nothing, and do things anyway.˙ I didn't know how
to parse the Intel Hex file format, before I added a "binary" loader
to the Mars MIPS emulator.˙ You know, the one written in Java.
It's not finished, but I have the basics down, and should be able to
load and run "binaries" with it soon.˙ I'll probably post screenshots
and they'll be hosted on Dropbox, so some of the other regulars won't
look.˙ That's on them.
Then, here the "Viswath & Charmaigne" is for the idea that there
are generous, usual sorts of algorithms, here "findings" and
"matchings", that can be implemented vector-wise scalar-word,
then that for things like: libc, POSIX tools, parsers, and
so on, or as among "text-utils", and for character handling,
that much like many of the distributions like Linux, FreeBSD,
and so on, have developed and released and made in their tree
the vectorized versions of string functions, that, there are
abstract models of regular "text algos" that make sense for
all modern commodity architectures in their default configuration,
for the system libraries and default toolset. For example, most
all of "text-utils" involves "findings" and "matchings", in a sense,
then as with regards to "sorting" and "translation" or "transformation", >>> which is not addressed.
So I gather you're interested in algorithms that "parallel" with SIMD
and other vector machinery?˙ And you mention "text-utils."˙ Have you
read /String Algorithms in C/ by Mailund?˙ He goes into the nitty gritty
details of string matching -- and you can trivially translate the code
to any other programming language as you learn from the book -- in the
context of DNA matching.˙ At least that's how I remember the book.˙ The
/about the author/ blurb at the start mentions he's a professor of bio-
informatics so that seems like a true memory.˙ I'll want to read the
book again soon.
In any case, there are algorithms, string search amongst them, that seem
eminently serial, and I'm not quite sure SIMD and related extensions are
immediately applicable.˙ And now I'm sure there are people -- and LLMs
-- just itching to "correct me" about that.˙ Let them, they don't bother
me.
The mentioned initialisms are, or were, awful sci.math trolls.
In the mean time, I've gathered a few names here in comp.lang.c that I'll
probably never reply to ever again.˙ They know who they are.
Thanks for the book reference, I'll look to it.
Decades ago when at the university I had a job working
for the biology department and what it was was making a graphical
front-end in Java to launch BLAST gene-sequence search on what
had as about 48 units / 96 cores Sun Silicon Grid Engine MPI cluster,
of Apple pizza boxes with PowerPC cores, then that also I wrote some
code for matching sequences with splitting the input and running the
cluster on the input files and chewing that up, sequences of human DNA
about 9 gigabytes, "seq-reader".
I made a simple dialog with making the command line arguments
for BLAST to launch, then added a features to increase or decrease
the font, that really blew their mind, these days it's often found
with "Shift-plus and Shift-minus".
Java's my main, if I know anything, that's what I know.
On 30/07/2026 9:59 PM, Ross Finlayson wrote:
On 07/30/2026 06:20 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 30/07/2026 4:47 AM, Ross Finlayson wrote:
Thanks for writing. Good luck with that.
Now, if we attain to some decorum, that would be refreshing.
Yes, that indeed would be refreshing. I'll refresh myself with some
Pepsi
before continuing this followup, hold on.
I "know" Java and am familiar with C/C++, and computer engineering.
I just claim I know nothing, and do things anyway. I didn't know how
to parse the Intel Hex file format, before I added a "binary" loader
to the Mars MIPS emulator. You know, the one written in Java.
It's not finished, but I have the basics down, and should be able to
load and run "binaries" with it soon. I'll probably post screenshots
and they'll be hosted on Dropbox, so some of the other regulars won't
look. That's on them.
Then, here the "Viswath & Charmaigne" is for the idea that there
are generous, usual sorts of algorithms, here "findings" and
"matchings", that can be implemented vector-wise scalar-word,
then that for things like: libc, POSIX tools, parsers, and
so on, or as among "text-utils", and for character handling,
that much like many of the distributions like Linux, FreeBSD,
and so on, have developed and released and made in their tree
the vectorized versions of string functions, that, there are
abstract models of regular "text algos" that make sense for
all modern commodity architectures in their default configuration,
for the system libraries and default toolset. For example, most
all of "text-utils" involves "findings" and "matchings", in a sense,
then as with regards to "sorting" and "translation" or
"transformation",
which is not addressed.
So I gather you're interested in algorithms that "parallel" with SIMD
and other vector machinery? And you mention "text-utils." Have you
read /String Algorithms in C/ by Mailund? He goes into the nitty gritty >>> details of string matching -- and you can trivially translate the code
to any other programming language as you learn from the book -- in the
context of DNA matching. At least that's how I remember the book. The
/about the author/ blurb at the start mentions he's a professor of bio-
informatics so that seems like a true memory. I'll want to read the
book again soon.
In any case, there are algorithms, string search amongst them, that seem >>> eminently serial, and I'm not quite sure SIMD and related extensions are >>> immediately applicable. And now I'm sure there are people -- and LLMs
-- just itching to "correct me" about that. Let them, they don't bother >>> me.
The mentioned initialisms are, or were, awful sci.math trolls.
In the mean time, I've gathered a few names here in comp.lang.c that
I'll
probably never reply to ever again. They know who they are.
Thanks for the book reference, I'll look to it.
Decades ago when at the university I had a job working
for the biology department and what it was was making a graphical
front-end in Java to launch BLAST gene-sequence search on what
had as about 48 units / 96 cores Sun Silicon Grid Engine MPI cluster,
of Apple pizza boxes with PowerPC cores, then that also I wrote some
code for matching sequences with splitting the input and running the
cluster on the input files and chewing that up, sequences of human DNA
about 9 gigabytes, "seq-reader".
I made a simple dialog with making the command line arguments
for BLAST to launch, then added a features to increase or decrease
the font, that really blew their mind, these days it's often found
with "Shift-plus and Shift-minus".
Java's my main, if I know anything, that's what I know.
Now I'm deep in Swing GUI. I had hoped to finish my Intel Hex loader
before replying, but as I uncommented more of my lines, I ran into
another null pointer exception. Turns out the GUI code expects to
find labels in the program, and in my binary there are no labels.
And to bother people bothered by cross postings, I'll continue.
I'm also working an a feature where the MIPS program can access a
"real" terminal. For now, and the convenience of people who don't
own a VT520,[1] I'm hooking it up to Putty. It turns out Java cannot
create a named pipe in Windows. So I did that part in C using JNI. At
a guess, that's easier than using the /more modern/ Java foreign
function interface, since I don't have to #include <windows.h> in the surrounding Java code.
Anyway, I'm now at the part where I have successfully sent and received
a single byte from Putty, via named pipe hosted by the JVM. The next
part of the task is to use that code to make a Mars /tool/ that hooks
into the MIPS virtual machine and acts more or less like a physical UART
with interrupts.
That's probably going to have to be with a reader and writer background threads, because Java doesn't have a concept of nonblocking reads nor
writes for RandomAccessFiles. Though full disclosure, I'm not too sure
about that, because I've seen some people talking about channels and
checking if something is .available(). That doesn't apply to me anyway because I'm using the raw Win32 ReadFile() and WriteFile() calls in
blocking mode.
And once that's done, I'll have to teach myself how to write MIPS
exception handlers. That'll be fun.
Now, on the other hand, since my gf is starting to learn Java too, do
you have any words of wisdom for newbies? I taught her "hello world,"
then the Swing "hello world," and then showed her how she can skip all
that with the WindowBuilder in Eclipse.
What do you suggest as the next step, because she'll be looking for employment in a few months when she's confident enough?
[1] Plus, I'm not sure mine will work without some sort of maintenance.
It'll be a pleasant surprise if it works next time I turn it on.
--
Johann | email: invalid -> com | http://www.myrkraverk.com/blog/
I'm not from the Internet, I just work there. | via Easynews.com
On 07/30/2026 08:19 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 30/07/2026 9:59 PM, Ross Finlayson wrote:
On 07/30/2026 06:20 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 30/07/2026 4:47 AM, Ross Finlayson wrote:
Thanks for writing. Good luck with that.
Now, if we attain to some decorum, that would be refreshing.
Yes, that indeed would be refreshing. I'll refresh myself with some
Pepsi
before continuing this followup, hold on.
I "know" Java and am familiar with C/C++, and computer engineering.
I just claim I know nothing, and do things anyway. I didn't know how
to parse the Intel Hex file format, before I added a "binary" loader
to the Mars MIPS emulator. You know, the one written in Java.
It's not finished, but I have the basics down, and should be able to
load and run "binaries" with it soon. I'll probably post screenshots
and they'll be hosted on Dropbox, so some of the other regulars won't
look. That's on them.
Then, here the "Viswath & Charmaigne" is for the idea that there
are generous, usual sorts of algorithms, here "findings" and
"matchings", that can be implemented vector-wise scalar-word,
then that for things like: libc, POSIX tools, parsers, and
so on, or as among "text-utils", and for character handling,
that much like many of the distributions like Linux, FreeBSD,
and so on, have developed and released and made in their tree
the vectorized versions of string functions, that, there are
abstract models of regular "text algos" that make sense for
all modern commodity architectures in their default configuration,
for the system libraries and default toolset. For example, most
all of "text-utils" involves "findings" and "matchings", in a sense, >>>>> then as with regards to "sorting" and "translation" or
"transformation",
which is not addressed.
So I gather you're interested in algorithms that "parallel" with SIMD
and other vector machinery? And you mention "text-utils." Have you
read /String Algorithms in C/ by Mailund? He goes into the nitty
gritty
details of string matching -- and you can trivially translate the code >>>> to any other programming language as you learn from the book -- in the >>>> context of DNA matching. At least that's how I remember the book. The >>>> /about the author/ blurb at the start mentions he's a professor of bio- >>>> informatics so that seems like a true memory. I'll want to read the
book again soon.
In any case, there are algorithms, string search amongst them, that
seem
eminently serial, and I'm not quite sure SIMD and related extensions
are
immediately applicable. And now I'm sure there are people -- and LLMs >>>> -- just itching to "correct me" about that. Let them, they don't
bother
me.
The mentioned initialisms are, or were, awful sci.math trolls.
In the mean time, I've gathered a few names here in comp.lang.c that
I'll
probably never reply to ever again. They know who they are.
Thanks for the book reference, I'll look to it.
Decades ago when at the university I had a job working
for the biology department and what it was was making a graphical
front-end in Java to launch BLAST gene-sequence search on what
had as about 48 units / 96 cores Sun Silicon Grid Engine MPI cluster,
of Apple pizza boxes with PowerPC cores, then that also I wrote some
code for matching sequences with splitting the input and running the
cluster on the input files and chewing that up, sequences of human DNA
about 9 gigabytes, "seq-reader".
I made a simple dialog with making the command line arguments
for BLAST to launch, then added a features to increase or decrease
the font, that really blew their mind, these days it's often found
with "Shift-plus and Shift-minus".
Java's my main, if I know anything, that's what I know.
Now I'm deep in Swing GUI. I had hoped to finish my Intel Hex loader
before replying, but as I uncommented more of my lines, I ran into
another null pointer exception. Turns out the GUI code expects to
find labels in the program, and in my binary there are no labels.
And to bother people bothered by cross postings, I'll continue.
I'm also working an a feature where the MIPS program can access a
"real" terminal. For now, and the convenience of people who don't
own a VT520,[1] I'm hooking it up to Putty. It turns out Java cannot
create a named pipe in Windows. So I did that part in C using JNI. At
a guess, that's easier than using the /more modern/ Java foreign
function interface, since I don't have to #include <windows.h> in the
surrounding Java code.
Anyway, I'm now at the part where I have successfully sent and received
a single byte from Putty, via named pipe hosted by the JVM. The next
part of the task is to use that code to make a Mars /tool/ that hooks
into the MIPS virtual machine and acts more or less like a physical UART
with interrupts.
That's probably going to have to be with a reader and writer background
threads, because Java doesn't have a concept of nonblocking reads nor
writes for RandomAccessFiles. Though full disclosure, I'm not too sure
about that, because I've seen some people talking about channels and
checking if something is .available(). That doesn't apply to me anyway
because I'm using the raw Win32 ReadFile() and WriteFile() calls in
blocking mode.
And once that's done, I'll have to teach myself how to write MIPS
exception handlers. That'll be fun.
Now, on the other hand, since my gf is starting to learn Java too, do
you have any words of wisdom for newbies? I taught her "hello world,"
then the Swing "hello world," and then showed her how she can skip all
that with the WindowBuilder in Eclipse.
What do you suggest as the next step, because she'll be looking for
employment in a few months when she's confident enough?
[1] Plus, I'm not sure mine will work without some sort of maintenance.
It'll be a pleasant surprise if it works next time I turn it on.
--
Johann | email: invalid -> com | http://www.myrkraverk.com/blog/
I'm not from the Internet, I just work there. | via Easynews.com
One might suggest that the "Java Trails" tutorials and "Core Java"
and "Java in a Nutshell" would give an authentic introduction that
were new then and old now, and correct, if not "current", then and now.
https://docs.oracle.com/javase/tutorial/
For something like C++, my first link would be
"https://cppreference.com", usually. Then after
the tutorials there is only API javadoc the API documentation,
which is also surfaced in the IDE's.
Java11 and C++ 11 are probably appropriate baselines.
I've programmed in both Swing and Win32, more low-level than high-level, Java's worker threads and sychronization utilities
vis-a-vis Win32's message-pump and message-crackers and the user-defined pointer in the HWND's MSG, make for various
accounts then for things like OLE/OLE2/COM/DCOM/ActiveX
as about the .NET IL ASM CLR runtime with C#, VB.NET, F#,
C/C++, and so on.
Yes, I also know "Angular/React and SPA frameworks,
in JavaScript and TypeScript".
Just downloading some other person's code
As I said elsewhere, I'm not that interested in Hack, but virtual
machines and related code.˙ I mentioned another book, but now I feel
I should ask if you've also read /Crafting Interpreters/ by Robert
Nystrom?˙ I myself am still on chapter 5, so I'm still in the Java
part of the book, so I replaced comp.lang.c++ with comp.lang.java, and
am fairly excited to have a working interpreter.
This is the type of book people only properly learn from by typing in
the code themselves.˙ Just downloading some other person's code, and
running an interpreter isn't exactly a learning experience.˙ So I'm
taking my time with it, and interleaving it with my Mars adventures.
In any case, I do wish you to have fun with your own WebGPU project,
whatever that is about!
Hi,
Just downloading some other person's code
I didn't do that, I wrote Hack VM for pi-WAM
from scratch, over the last 4 weeks. I came
back from holidays on end of June 2026, and now
we have end of July 2026. But its only possible
because the instruction set is very smal, like
ca. 8 functions and ca. 8 modes and ca. 8 conditions,
so its ca. 8 x 8 x 8 = 512 opcodes, each has an
A parameter and a D parameter simultaneously.
It has currently the following CPU backends:
˙- Nnow supports interleaved synchronous emulation.
˙- Now supports warp parallelism via Java platform threads.
˙- Now supports warp parallelism via Python system threads.
˙- Now supports warp parallelism via JavaScript worker threads.
˙- Note: For Python free threads are not yet fully tested.
˙- Note: For JavaScript web workers are not yet fully tested.
https://www.dogelog.ch/typtab/doclet/book/14_install/05_notes22/110_224.html
But frankly I came to encounter Hack not from
the usual university curriculum web resources,
but indirectly through a post about a Prolog
emulation of Hack, using constrained horn clauses (CHC):
Verifying Nand2Tetris Assembly
https://www.philipzucker.com/nand2tetris-chc/
The binary encoding is currently that the functions,
modes and conditions eat up a nibble (4-bit), in
total 12-bit, which I use then 10-bit for A parameter
and 10-bit for D parameter. I used AI freemium, Codex
by ChatGPT from within IntelliJ to do some fragment
code translations automatically from Java to JavaScript
or from JavaScript to Python.
Have Fun!
Bye
Johann 'Myrkraverk' Oskarsson schrieb:
As I said elsewhere, I'm not that interested in Hack, but virtual
machines and related code.˙ I mentioned another book, but now I feel
I should ask if you've also read /Crafting Interpreters/ by Robert
Nystrom?˙ I myself am still on chapter 5, so I'm still in the Java
part of the book, so I replaced comp.lang.c++ with comp.lang.java, and
am fairly excited to have a working interpreter.
This is the type of book people only properly learn from by typing in
the code themselves.˙ Just downloading some other person's code, and
running an interpreter isn't exactly a learning experience.˙ So I'm
taking my time with it, and interleaving it with my Mars adventures.
In any case, I do wish you to have fun with your own WebGPU project,
whatever that is about!
Hi,
The op-codes are all uniform, have the
same sub fields. Already Z-80 CPU differs here.
Another difference to a Z-80 CPU is that
their instruction stream was 8-bit, instructions
can 1, 2, 3 or 4 byte long. On the other
hand in my Hack VM all instructions are
one 32-bit chunk. The porting of a first
prototype that I already had, to WebGPU / WGSL
only took like 1-2 hours. The execution
of Hack VM is very simple, veersion 1.0,
for a single shader:
fn run() {
˙˙˙ var pc : i32 = 0;
˙˙˙ var accu : i32 = 0;
˙˙˙ while (pc < i32(arrayLength(&code))) {
˙˙˙˙˙˙˙ var instr : i32 = code[pc];
˙˙˙˙˙˙˙ pc += 1;
˙˙˙˙˙˙˙ var value : i32 = run_get(instr);
˙˙˙˙˙˙˙ accu = run_fun(instr, accu, value);
˙˙˙˙˙˙˙ run_set(instr, accu);
˙˙˙˙˙˙˙ pc += run_jump(instr, accu);
˙˙˙ }
}
https://github.com/Jean-Luc-Picard-2021/gigabudget/blob/b8946e891be774c40522267ab17062d32b023e7a/course/example63/boot.mjs#L176-L187
I first though this will be perfect for
SIMD. Until I learnt that modern GPUs have
anyway MIMD. Hell Yeah, thats much better!
Bye
Mild Shock schrieb:
Hi,
Just downloading some other person's code
I didn't do that, I wrote Hack VM for pi-WAM
from scratch, over the last 4 weeks. I came
back from holidays on end of June 2026, and now
we have end of July 2026. But its only possible
because the instruction set is very smal, like
ca. 8 functions and ca. 8 modes and ca. 8 conditions,
so its ca. 8 x 8 x 8 = 512 opcodes, each has an
A parameter and a D parameter simultaneously.
It has currently the following CPU backends:
˙˙- Nnow supports interleaved synchronous emulation.
˙˙- Now supports warp parallelism via Java platform threads.
˙˙- Now supports warp parallelism via Python system threads.
˙˙- Now supports warp parallelism via JavaScript worker threads.
˙˙- Note: For Python free threads are not yet fully tested.
˙˙- Note: For JavaScript web workers are not yet fully tested.
https://www.dogelog.ch/typtab/doclet/book/14_install/05_notes22/110_224.html
But frankly I came to encounter Hack not from
the usual university curriculum web resources,
but indirectly through a post about a Prolog
emulation of Hack, using constrained horn clauses (CHC):
Verifying Nand2Tetris Assembly
https://www.philipzucker.com/nand2tetris-chc/
The binary encoding is currently that the functions,
modes and conditions eat up a nibble (4-bit), in
total 12-bit, which I use then 10-bit for A parameter
and 10-bit for D parameter. I used AI freemium, Codex
by ChatGPT from within IntelliJ to do some fragment
code translations automatically from Java to JavaScript
or from JavaScript to Python.
Have Fun!
Bye
Johann 'Myrkraverk' Oskarsson schrieb:
As I said elsewhere, I'm not that interested in Hack, but virtual
machines and related code.˙ I mentioned another book, but now I feel
I should ask if you've also read /Crafting Interpreters/ by Robert
Nystrom?˙ I myself am still on chapter 5, so I'm still in the Java
part of the book, so I replaced comp.lang.c++ with comp.lang.java, and
am fairly excited to have a working interpreter.
This is the type of book people only properly learn from by typing in
the code themselves.˙ Just downloading some other person's code, and
running an interpreter isn't exactly a learning experience.˙ So I'm
taking my time with it, and interleaving it with my Mars adventures.
In any case, I do wish you to have fun with your own WebGPU project,
whatever that is about!
Hi,
Just downloading some other person's code
I didn't do that, I wrote Hack VM for pi-WAM
from scratch, over the last 4 weeks. I came
back from holidays on end of June 2026, and now
we have end of July 2026. But its only possible
because the instruction set is very smal, like
ca. 8 functions and ca. 8 modes and ca. 8 conditions,
so its ca. 8 x 8 x 8 = 512 opcodes, each has an
A parameter and a D parameter simultaneously.
It has currently the following CPU backends:
˙- Nnow supports interleaved synchronous emulation.
˙- Now supports warp parallelism via Java platform threads.
˙- Now supports warp parallelism via Python system threads.
˙- Now supports warp parallelism via JavaScript worker threads.
˙- Note: For Python free threads are not yet fully tested.
˙- Note: For JavaScript web workers are not yet fully tested.
https://www.dogelog.ch/typtab/doclet/ book/14_install/05_notes22/110_224.html
But frankly I came to encounter Hack not from
the usual university curriculum web resources,
but indirectly through a post about a Prolog
emulation of Hack, using constrained horn clauses (CHC):
Verifying Nand2Tetris Assembly
https://www.philipzucker.com/nand2tetris-chc/
The binary encoding is currently that the functions,
modes and conditions eat up a nibble (4-bit), in
total 12-bit, which I use then 10-bit for A parameter
and 10-bit for D parameter. I used AI freemium, Codex
by ChatGPT from within IntelliJ to do some fragment
code translations automatically from Java to JavaScript
or from JavaScript to Python.
Have Fun!
Hi,
The op-codes are all uniform, have the
same sub fields. Already Z-80 CPU differs here.
Another difference to a Z-80 CPU is that
their instruction stream was 8-bit, instructions
can 1, 2, 3 or 4 byte long. On the other
hand in my Hack VM all instructions are
one 32-bit chunk.
The porting of a first
prototype that I already had, to WebGPU / WGSL
only took like 1-2 hours. The execution
of Hack VM is very simple, veersion 1.0,
for a single shader:
fn run() {
˙˙˙ var pc : i32 = 0;
˙˙˙ var accu : i32 = 0;
˙˙˙ while (pc < i32(arrayLength(&code))) {
˙˙˙˙˙˙˙ var instr : i32 = code[pc];
˙˙˙˙˙˙˙ pc += 1;
˙˙˙˙˙˙˙ var value : i32 = run_get(instr);
˙˙˙˙˙˙˙ accu = run_fun(instr, accu, value);
˙˙˙˙˙˙˙ run_set(instr, accu);
˙˙˙˙˙˙˙ pc += run_jump(instr, accu);
˙˙˙ }
}
https://github.com/Jean-Luc-Picard-2021/gigabudget/blob/ b8946e891be774c40522267ab17062d32b023e7a/course/example63/boot.mjs#L176- L187
I first though this will be perfect for
SIMD. Until I learnt that modern GPUs have
anyway MIMD. Hell Yeah, thats much better!
Bye
Hi,
Just downloading some other person's code
I didn't do that, I wrote Hack VM for pi-WAM
from scratch, over the last 4 weeks. I came
back from holidays on end of June 2026, and now
we have end of July 2026. But its only possible
because the instruction set is very smal, like
ca. 8 functions and ca. 8 modes and ca. 8 conditions,
so its ca. 8 x 8 x 8 = 512 opcodes, each has an
A parameter and a D parameter simultaneously.
It has currently the following CPU backends:
˙- Nnow supports interleaved synchronous emulation.
˙- Now supports warp parallelism via Java platform threads.
˙- Now supports warp parallelism via Python system threads.
˙- Now supports warp parallelism via JavaScript worker threads.
˙- Note: For Python free threads are not yet fully tested.
˙- Note: For JavaScript web workers are not yet fully tested.
https://www.dogelog.ch/typtab/doclet/book/14_install/05_notes22/110_224.html
But frankly I came to encounter Hack not from
the usual university curriculum web resources,
but indirectly through a post about a Prolog
emulation of Hack, using constrained horn clauses (CHC):
Verifying Nand2Tetris Assembly
https://www.philipzucker.com/nand2tetris-chc/
The binary encoding is currently that the functions,
modes and conditions eat up a nibble (4-bit), in
total 12-bit, which I use then 10-bit for A parameter
and 10-bit for D parameter. I used AI freemium, Codex
by ChatGPT from within IntelliJ to do some fragment
code translations automatically from Java to JavaScript
or from JavaScript to Python.
Have Fun!
Bye
Johann 'Myrkraverk' Oskarsson schrieb:
As I said elsewhere, I'm not that interested in Hack, but virtual
machines and related code.˙ I mentioned another book, but now I feel
I should ask if you've also read /Crafting Interpreters/ by Robert
Nystrom?˙ I myself am still on chapter 5, so I'm still in the Java
part of the book, so I replaced comp.lang.c++ with comp.lang.java, and
am fairly excited to have a working interpreter.
This is the type of book people only properly learn from by typing in
the code themselves.˙ Just downloading some other person's code, and
running an interpreter isn't exactly a learning experience.˙ So I'm
taking my time with it, and interleaving it with my Mars adventures.
In any case, I do wish you to have fun with your own WebGPU project,
whatever that is about!
Hi,
There is Prolog compiler which spits out Hack.
From there on your are free to develop
and/or use any Hack realization that goes
from abstract to concrete. You could
replace the CPU backends that realize
a Hack VM by MIPS. Shouldn't be difficult.
Basically I refused to think in Huffman
Coding (*) while designing Hack VM. On the
other hand the MIPS architecture looks
like a big Huffman mess. Already its
initial design has 3 instructions types:
Type format (bits)
R opcode(6) rs(5) rt(5) rd(5) shamt(5) funct(6)
I opcode(6) rs(5) rt(5) imme(16)
J opcode(6) addr(26)
While my Hack has only 1 instruction
type, when binary encoded for Hack VM,
the currently used design looks as follows:
Type format (bits)
AD opcode(4) mode(4) cond(4) imme(10) addr(10)
But since its an abstract machine, nothing
prevents you from translating Hack code
into MIPS before executing it.
In has far you have to distinguish Hack,
which is specified in Prolog. And Hack VM
which is a virtual machine, with the above
instruction packing. And which has currently
a JavaScript runtime, a Python runtime
and a Java runtime.
Bye
(*)
https://en.wikipedia.org/wiki/Huffman_coding
RF, good to join the panel. I appreciate the format?direct address and genuine exchange rather than parallel monologues.[4368 lines deleted]
On 07/30/2026 09:23 AM, Ross Finlayson wrote:
On 07/30/2026 08:19 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 30/07/2026 9:59 PM, Ross Finlayson wrote:
On 07/30/2026 06:20 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 30/07/2026 4:47 AM, Ross Finlayson wrote:
Thanks for writing. Good luck with that.
Now, if we attain to some decorum, that would be refreshing.
Yes, that indeed would be refreshing.˙ I'll refresh myself with some >>>>> Pepsi
before continuing this followup, hold on.
I just claim I know nothing, and do things anyway.˙ I didn't know how >>>>> to parse the Intel Hex file format, before I added a "binary" loader >>>>> to the Mars MIPS emulator.˙ You know, the one written in Java.
I "know" Java and am familiar with C/C++, and computer engineering. >>>>>
It's not finished, but I have the basics down, and should be able to >>>>> load and run "binaries" with it soon.˙ I'll probably post screenshots >>>>> and they'll be hosted on Dropbox, so some of the other regulars won't >>>>> look.˙ That's on them.
Then, here the "Viswath & Charmaigne" is for the idea that there
are generous, usual sorts of algorithms, here "findings" and
"matchings", that can be implemented vector-wise scalar-word,
then that for things like: libc, POSIX tools, parsers, and
so on, or as among "text-utils", and for character handling,
that much like many of the distributions like Linux, FreeBSD,
and so on, have developed and released and made in their tree
the vectorized versions of string functions, that, there are
abstract models of regular "text algos" that make sense for
all modern commodity architectures in their default configuration, >>>>>> for the system libraries and default toolset. For example, most
all of "text-utils" involves "findings" and "matchings", in a sense, >>>>>> then as with regards to "sorting" and "translation" or
"transformation",
which is not addressed.
So I gather you're interested in algorithms that "parallel" with SIMD >>>>> and other vector machinery?˙ And you mention "text-utils."˙ Have you >>>>> read /String Algorithms in C/ by Mailund?˙ He goes into the nitty
gritty
details of string matching -- and you can trivially translate the code >>>>> to any other programming language as you learn from the book -- in the >>>>> context of DNA matching.˙ At least that's how I remember the book. >>>>> The
/about the author/ blurb at the start mentions he's a professor of
bio-
informatics so that seems like a true memory.˙ I'll want to read the >>>>> book again soon.
In any case, there are algorithms, string search amongst them, that
seem
eminently serial, and I'm not quite sure SIMD and related extensions >>>>> are
immediately applicable.˙ And now I'm sure there are people -- and LLMs >>>>> -- just itching to "correct me" about that.˙ Let them, they don't
bother
me.
The mentioned initialisms are, or were, awful sci.math trolls.
In the mean time, I've gathered a few names here in comp.lang.c that >>>>> I'll
probably never reply to ever again.˙ They know who they are.
Thanks for the book reference, I'll look to it.
Decades ago when at the university I had a job working
for the biology department and what it was was making a graphical
front-end in Java to launch BLAST gene-sequence search on what
had as about 48 units / 96 cores Sun Silicon Grid Engine MPI cluster,
of Apple pizza boxes with PowerPC cores, then that also I wrote some
code for matching sequences with splitting the input and running the
cluster on the input files and chewing that up, sequences of human DNA >>>> about 9 gigabytes, "seq-reader".
I made a simple dialog with making the command line arguments
for BLAST to launch, then added a features to increase or decrease
the font, that really blew their mind, these days it's often found
with "Shift-plus and Shift-minus".
Java's my main, if I know anything, that's what I know.
Now I'm deep in Swing GUI.˙ I had hoped to finish my Intel Hex loader
before replying, but as I uncommented more of my lines, I ran into
another null pointer exception.˙ Turns out the GUI code expects to
find labels in the program, and in my binary there are no labels.
And to bother people bothered by cross postings, I'll continue.
I'm also working an a feature where the MIPS program can access a
"real" terminal.˙ For now, and the convenience of people who don't
own a VT520,[1] I'm hooking it up to Putty.˙ It turns out Java cannot
create a named pipe in Windows.˙ So I did that part in C using JNI.˙ At
a guess, that's easier than using the /more modern/ Java foreign
function interface, since I don't have to #include <windows.h> in the
surrounding Java code.
Anyway, I'm now at the part where I have successfully sent and received
a single byte from Putty, via named pipe hosted by the JVM.˙ The next
part of the task is to use that code to make a Mars /tool/ that hooks
into the MIPS virtual machine and acts more or less like a physical UART >>> with interrupts.
That's probably going to have to be with a reader and writer background
threads, because Java doesn't have a concept of nonblocking reads nor
writes for RandomAccessFiles.˙ Though full disclosure, I'm not too sure
about that, because I've seen some people talking about channels and
checking if something is .available().˙ That doesn't apply to me anyway
because I'm using the raw Win32 ReadFile() and WriteFile() calls in
blocking mode.
And once that's done, I'll have to teach myself how to write MIPS
exception handlers.˙ That'll be fun.
Now, on the other hand, since my gf is starting to learn Java too, do
you have any words of wisdom for newbies?˙ I taught her "hello world,"
then the Swing "hello world," and then showed her how she can skip all
that with the WindowBuilder in Eclipse.
What do you suggest as the next step, because she'll be looking for
employment in a few months when she's confident enough?
[1] Plus, I'm not sure mine will work without some sort of maintenance.
˙˙˙˙ It'll be a pleasant surprise if it works next time I turn it on.
--
Johann | email: invalid -> com | http://www.myrkraverk.com/blog/
I'm not from the Internet, I just work there. | via Easynews.com
One might suggest that the "Java Trails" tutorials and "Core Java"
and "Java in a Nutshell" would give an authentic introduction that
were new then and old now, and correct, if not "current", then and now.
https://docs.oracle.com/javase/tutorial/
For something like C++, my first link would be
"https://cppreference.com", usually. Then after
the tutorials there is only API javadoc the API documentation,
which is also surfaced in the IDE's.
Java11 and C++ 11 are probably appropriate baselines.
I've programmed in both Swing and Win32, more low-level than high-level,
Java's worker threads and sychronization utilities
vis-a-vis Win32's message-pump and message-crackers and the user-defined
pointer in the HWND's MSG, make for various
accounts then for things like OLE/OLE2/COM/DCOM/ActiveX
as about the .NET IL ASM CLR runtime with C#, VB.NET, F#,
C/C++, and so on.
I leafed through all the Windows 7 sources before,
at work working on Windows, one task I had was to
implement highlighting "Find..." matches in the UI,
I added to highlight all the matches by using the font
metrics and some calculations and a palette, within a
few years it was part of the usual UI experience in
according to things like the "Win32 UI Guidelines/Principles",
similarly to how font-scaling later became ubiquitous,
simply because those are useful features. Before "ribbons",
or, "progressive affordance in UX/UI" and all that there were
common UI design outlines. Here there's a notion of a
"Light User Interface" experience or "LUI" that then happens
to have renderings in "HTML forms" and the like.
Yes, I also know "Angular/React and SPA frameworks,
in JavaScript and TypeScript".
On 31/07/2026 12:36 AM, Ross Finlayson wrote:
On 07/30/2026 09:23 AM, Ross Finlayson wrote:
On 07/30/2026 08:19 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 30/07/2026 9:59 PM, Ross Finlayson wrote:
On 07/30/2026 06:20 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 30/07/2026 4:47 AM, Ross Finlayson wrote:
Thanks for writing. Good luck with that.
Now, if we attain to some decorum, that would be refreshing.
Yes, that indeed would be refreshing. I'll refresh myself with some >>>>>> Pepsi
before continuing this followup, hold on.
I just claim I know nothing, and do things anyway. I didn't know how >>>>>> to parse the Intel Hex file format, before I added a "binary" loader >>>>>> to the Mars MIPS emulator. You know, the one written in Java.
I "know" Java and am familiar with C/C++, and computer engineering. >>>>>>
It's not finished, but I have the basics down, and should be able to >>>>>> load and run "binaries" with it soon. I'll probably post screenshots >>>>>> and they'll be hosted on Dropbox, so some of the other regulars won't >>>>>> look. That's on them.
Then, here the "Viswath & Charmaigne" is for the idea that there >>>>>>> are generous, usual sorts of algorithms, here "findings" and
"matchings", that can be implemented vector-wise scalar-word,
then that for things like: libc, POSIX tools, parsers, and
so on, or as among "text-utils", and for character handling,
that much like many of the distributions like Linux, FreeBSD,
and so on, have developed and released and made in their tree
the vectorized versions of string functions, that, there are
abstract models of regular "text algos" that make sense for
all modern commodity architectures in their default configuration, >>>>>>> for the system libraries and default toolset. For example, most
all of "text-utils" involves "findings" and "matchings", in a sense, >>>>>>> then as with regards to "sorting" and "translation" or
"transformation",
which is not addressed.
So I gather you're interested in algorithms that "parallel" with SIMD >>>>>> and other vector machinery? And you mention "text-utils." Have you >>>>>> read /String Algorithms in C/ by Mailund? He goes into the nitty
gritty
details of string matching -- and you can trivially translate the
code
to any other programming language as you learn from the book -- in >>>>>> the
context of DNA matching. At least that's how I remember the book. >>>>>> The
/about the author/ blurb at the start mentions he's a professor of >>>>>> bio-
informatics so that seems like a true memory. I'll want to read the >>>>>> book again soon.
In any case, there are algorithms, string search amongst them, that >>>>>> seem
eminently serial, and I'm not quite sure SIMD and related extensions >>>>>> are
immediately applicable. And now I'm sure there are people -- and
LLMs
-- just itching to "correct me" about that. Let them, they don't
bother
me.
The mentioned initialisms are, or were, awful sci.math trolls.
In the mean time, I've gathered a few names here in comp.lang.c that >>>>>> I'll
probably never reply to ever again. They know who they are.
Thanks for the book reference, I'll look to it.
Decades ago when at the university I had a job working
for the biology department and what it was was making a graphical
front-end in Java to launch BLAST gene-sequence search on what
had as about 48 units / 96 cores Sun Silicon Grid Engine MPI cluster, >>>>> of Apple pizza boxes with PowerPC cores, then that also I wrote some >>>>> code for matching sequences with splitting the input and running the >>>>> cluster on the input files and chewing that up, sequences of human DNA >>>>> about 9 gigabytes, "seq-reader".
I made a simple dialog with making the command line arguments
for BLAST to launch, then added a features to increase or decrease
the font, that really blew their mind, these days it's often found
with "Shift-plus and Shift-minus".
Java's my main, if I know anything, that's what I know.
Now I'm deep in Swing GUI. I had hoped to finish my Intel Hex loader
before replying, but as I uncommented more of my lines, I ran into
another null pointer exception. Turns out the GUI code expects to
find labels in the program, and in my binary there are no labels.
And to bother people bothered by cross postings, I'll continue.
I'm also working an a feature where the MIPS program can access a
"real" terminal. For now, and the convenience of people who don't
own a VT520,[1] I'm hooking it up to Putty. It turns out Java cannot
create a named pipe in Windows. So I did that part in C using JNI. At >>>> a guess, that's easier than using the /more modern/ Java foreign
function interface, since I don't have to #include <windows.h> in the
surrounding Java code.
Anyway, I'm now at the part where I have successfully sent and received >>>> a single byte from Putty, via named pipe hosted by the JVM. The next
part of the task is to use that code to make a Mars /tool/ that hooks
into the MIPS virtual machine and acts more or less like a physical
UART
with interrupts.
That's probably going to have to be with a reader and writer background >>>> threads, because Java doesn't have a concept of nonblocking reads nor
writes for RandomAccessFiles. Though full disclosure, I'm not too sure >>>> about that, because I've seen some people talking about channels and
checking if something is .available(). That doesn't apply to me anyway >>>> because I'm using the raw Win32 ReadFile() and WriteFile() calls in
blocking mode.
And once that's done, I'll have to teach myself how to write MIPS
exception handlers. That'll be fun.
Now, on the other hand, since my gf is starting to learn Java too, do
you have any words of wisdom for newbies? I taught her "hello world," >>>> then the Swing "hello world," and then showed her how she can skip all >>>> that with the WindowBuilder in Eclipse.
What do you suggest as the next step, because she'll be looking for
employment in a few months when she's confident enough?
[1] Plus, I'm not sure mine will work without some sort of maintenance. >>>> It'll be a pleasant surprise if it works next time I turn it on.
--
Johann | email: invalid -> com | http://www.myrkraverk.com/blog/
I'm not from the Internet, I just work there. | via Easynews.com
One might suggest that the "Java Trails" tutorials and "Core Java"
and "Java in a Nutshell" would give an authentic introduction that
were new then and old now, and correct, if not "current", then and now.
https://docs.oracle.com/javase/tutorial/
I'll take a look at those. I didn't think of using those as a teaching material before. I've just gone through some programs I've written
myself, sort of, so far.
For something like C++, my first link would be
"https://cppreference.com", usually. Then after
the tutorials there is only API javadoc the API documentation,
which is also surfaced in the IDE's.
Java11 and C++ 11 are probably appropriate baselines.
I tend to tell newbies to learn approximately C++98, then move on to a project, and learn the rest on the go. Some people have a problem with
that advice, and think I'm telling people to stop learning after C++98.
They have a reading comprehension problem.
For the usual APIs written in C++, C++98 is sufficient anyway.
I've programmed in both Swing and Win32, more low-level than high-level, >>> Java's worker threads and sychronization utilities
vis-a-vis Win32's message-pump and message-crackers and the user-defined >>> pointer in the HWND's MSG, make for various
accounts then for things like OLE/OLE2/COM/DCOM/ActiveX
as about the .NET IL ASM CLR runtime with C#, VB.NET, F#,
C/C++, and so on.
I sometimes wonder if I should implement my own COM. I forgot about it before, but I do have the /Inside COM/ book, for that purpose.
I leafed through all the Windows 7 sources before,
at work working on Windows, one task I had was to
implement highlighting "Find..." matches in the UI,
I added to highlight all the matches by using the font
metrics and some calculations and a palette, within a
few years it was part of the usual UI experience in
according to things like the "Win32 UI Guidelines/Principles",
similarly to how font-scaling later became ubiquitous,
simply because those are useful features. Before "ribbons",
or, "progressive affordance in UX/UI" and all that there were
common UI design outlines. Here there's a notion of a
"Light User Interface" experience or "LUI" that then happens
to have renderings in "HTML forms" and the like.
Yes, I also know "Angular/React and SPA frameworks,
in JavaScript and TypeScript".
That's interesting. I've almost never done user interfaces at a job.
I've mostly been a database, performance, backend, middleware and even
a kernel guy once.
I tried to debug a core dump of FreeBSD once, but the kernel that dumped wasn't the most recent, and I didn't have the "budget" to build a custom kernel from a few updates ago to get the debugging symbols, and gave up.
I've heard Microsoft behaved similarly, and overwrite their debugging symbols. I hope it's been fixed, because I believe that was a "bug."
And I've mostly managed to avoid jobs and projects that involve
JavaScript.
Have a nice day!
On 07/31/2026 08:07 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 31/07/2026 12:36 AM, Ross Finlayson wrote:
On 07/30/2026 09:23 AM, Ross Finlayson wrote:
On 07/30/2026 08:19 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 30/07/2026 9:59 PM, Ross Finlayson wrote:
On 07/30/2026 06:20 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 30/07/2026 4:47 AM, Ross Finlayson wrote:
Thanks for writing. Good luck with that.
Now, if we attain to some decorum, that would be refreshing.
Yes, that indeed would be refreshing. I'll refresh myself with some >>>>>>> Pepsi
before continuing this followup, hold on.
I just claim I know nothing, and do things anyway. I didn't know >>>>>>> how
I "know" Java and am familiar with C/C++, and computer engineering. >>>>>>>
to parse the Intel Hex file format, before I added a "binary" loader >>>>>>> to the Mars MIPS emulator. You know, the one written in Java.
It's not finished, but I have the basics down, and should be able to >>>>>>> load and run "binaries" with it soon. I'll probably post
screenshots
and they'll be hosted on Dropbox, so some of the other regulars
won't
look. That's on them.
Then, here the "Viswath & Charmaigne" is for the idea that there >>>>>>>> are generous, usual sorts of algorithms, here "findings" and
"matchings", that can be implemented vector-wise scalar-word,
then that for things like: libc, POSIX tools, parsers, and
so on, or as among "text-utils", and for character handling,
that much like many of the distributions like Linux, FreeBSD,
and so on, have developed and released and made in their tree
the vectorized versions of string functions, that, there are
abstract models of regular "text algos" that make sense for
all modern commodity architectures in their default configuration, >>>>>>>> for the system libraries and default toolset. For example, most >>>>>>>> all of "text-utils" involves "findings" and "matchings", in a
sense,
then as with regards to "sorting" and "translation" or
"transformation",
which is not addressed.
So I gather you're interested in algorithms that "parallel" with >>>>>>> SIMD
and other vector machinery? And you mention "text-utils." Have you >>>>>>> read /String Algorithms in C/ by Mailund? He goes into the nitty >>>>>>> gritty
details of string matching -- and you can trivially translate the >>>>>>> code
to any other programming language as you learn from the book -- in >>>>>>> the
context of DNA matching. At least that's how I remember the book. >>>>>>> The
/about the author/ blurb at the start mentions he's a professor of >>>>>>> bio-
informatics so that seems like a true memory. I'll want to read the >>>>>>> book again soon.
In any case, there are algorithms, string search amongst them, that >>>>>>> seem
eminently serial, and I'm not quite sure SIMD and related extensions >>>>>>> are
immediately applicable. And now I'm sure there are people -- and >>>>>>> LLMs
-- just itching to "correct me" about that. Let them, they don't >>>>>>> bother
me.
The mentioned initialisms are, or were, awful sci.math trolls.
In the mean time, I've gathered a few names here in comp.lang.c that >>>>>>> I'll
probably never reply to ever again. They know who they are.
Thanks for the book reference, I'll look to it.
Decades ago when at the university I had a job working
for the biology department and what it was was making a graphical
front-end in Java to launch BLAST gene-sequence search on what
had as about 48 units / 96 cores Sun Silicon Grid Engine MPI cluster, >>>>>> of Apple pizza boxes with PowerPC cores, then that also I wrote some >>>>>> code for matching sequences with splitting the input and running the >>>>>> cluster on the input files and chewing that up, sequences of human >>>>>> DNA
about 9 gigabytes, "seq-reader".
I made a simple dialog with making the command line arguments
for BLAST to launch, then added a features to increase or decrease >>>>>> the font, that really blew their mind, these days it's often found >>>>>> with "Shift-plus and Shift-minus".
Java's my main, if I know anything, that's what I know.
Now I'm deep in Swing GUI. I had hoped to finish my Intel Hex loader >>>>> before replying, but as I uncommented more of my lines, I ran into
another null pointer exception. Turns out the GUI code expects to
find labels in the program, and in my binary there are no labels.
And to bother people bothered by cross postings, I'll continue.
I'm also working an a feature where the MIPS program can access a
"real" terminal. For now, and the convenience of people who don't
own a VT520,[1] I'm hooking it up to Putty. It turns out Java cannot >>>>> create a named pipe in Windows. So I did that part in C using
JNI. At
a guess, that's easier than using the /more modern/ Java foreign
function interface, since I don't have to #include <windows.h> in the >>>>> surrounding Java code.
Anyway, I'm now at the part where I have successfully sent and
received
a single byte from Putty, via named pipe hosted by the JVM. The next >>>>> part of the task is to use that code to make a Mars /tool/ that hooks >>>>> into the MIPS virtual machine and acts more or less like a physical
UART
with interrupts.
That's probably going to have to be with a reader and writer
background
threads, because Java doesn't have a concept of nonblocking reads nor >>>>> writes for RandomAccessFiles. Though full disclosure, I'm not too
sure
about that, because I've seen some people talking about channels and >>>>> checking if something is .available(). That doesn't apply to me
anyway
because I'm using the raw Win32 ReadFile() and WriteFile() calls in
blocking mode.
And once that's done, I'll have to teach myself how to write MIPS
exception handlers. That'll be fun.
Now, on the other hand, since my gf is starting to learn Java too, do >>>>> you have any words of wisdom for newbies? I taught her "hello world," >>>>> then the Swing "hello world," and then showed her how she can skip all >>>>> that with the WindowBuilder in Eclipse.
What do you suggest as the next step, because she'll be looking for
employment in a few months when she's confident enough?
[1] Plus, I'm not sure mine will work without some sort of
maintenance.
It'll be a pleasant surprise if it works next time I turn it on. >>>>> --
Johann | email: invalid -> com | http://www.myrkraverk.com/blog/
I'm not from the Internet, I just work there. | via Easynews.com
One might suggest that the "Java Trails" tutorials and "Core Java"
and "Java in a Nutshell" would give an authentic introduction that
were new then and old now, and correct, if not "current", then and now. >>>>
https://docs.oracle.com/javase/tutorial/
I'll take a look at those. I didn't think of using those as a teaching
material before. I've just gone through some programs I've written
myself, sort of, so far.
For something like C++, my first link would be
"https://cppreference.com", usually. Then after
the tutorials there is only API javadoc the API documentation,
which is also surfaced in the IDE's.
Java11 and C++ 11 are probably appropriate baselines.
I tend to tell newbies to learn approximately C++98, then move on to a
project, and learn the rest on the go. Some people have a problem with
that advice, and think I'm telling people to stop learning after C++98.
They have a reading comprehension problem.
For the usual APIs written in C++, C++98 is sufficient anyway.
I've programmed in both Swing and Win32, more low-level than
high-level,
Java's worker threads and sychronization utilities
vis-a-vis Win32's message-pump and message-crackers and the
user-defined
pointer in the HWND's MSG, make for various
accounts then for things like OLE/OLE2/COM/DCOM/ActiveX
as about the .NET IL ASM CLR runtime with C#, VB.NET, F#,
C/C++, and so on.
I sometimes wonder if I should implement my own COM. I forgot about it
before, but I do have the /Inside COM/ book, for that purpose.
I leafed through all the Windows 7 sources before,
at work working on Windows, one task I had was to
implement highlighting "Find..." matches in the UI,
I added to highlight all the matches by using the font
metrics and some calculations and a palette, within a
few years it was part of the usual UI experience in
according to things like the "Win32 UI Guidelines/Principles",
similarly to how font-scaling later became ubiquitous,
simply because those are useful features. Before "ribbons",
or, "progressive affordance in UX/UI" and all that there were
common UI design outlines. Here there's a notion of a
"Light User Interface" experience or "LUI" that then happens
to have renderings in "HTML forms" and the like.
Yes, I also know "Angular/React and SPA frameworks,
in JavaScript and TypeScript".
That's interesting. I've almost never done user interfaces at a job.
I've mostly been a database, performance, backend, middleware and even
a kernel guy once.
I tried to debug a core dump of FreeBSD once, but the kernel that dumped
wasn't the most recent, and I didn't have the "budget" to build a custom
kernel from a few updates ago to get the debugging symbols, and gave up.
I've heard Microsoft behaved similarly, and overwrite their debugging
symbols. I hope it's been fixed, because I believe that was a "bug."
And I've mostly managed to avoid jobs and projects that involve
JavaScript.
Have a nice day!
No man is an island, and any language has its models.
There's a usual sense of the decorum and the etiquette
the "obligatory", abbreviated in some slang some decades
ago as the "ob", alike the "obquote" or otherwise "topicality",
with the idea being that threads are mostly their own space.
The joke about Rust and people saying "use Rust because it's
efficient and it's safe", then the "how's it efficient and
safe" then the "it's efficient by not being safe and safe by
not being efficient", reflects on "compromise" vis-a-vis
"decision", in tradeoffs. Then today's is about CISC and
RISC, and it's that CISC has complicated instructions and
RISC has reduced instruction, yet CISC has reduced operands
and RISC has complicated operands.
Then, making a deconstructive and reflective account, then
how that applies to C/C++, which I tend to club together,
since at some point a C++ program will rely on C linkage,
or the system libraries, is that C++ has a great account
of being efficient, while being safe.
About C++ 03, since it has templates, traits,and RTTI,
then as with regards to allocator copy and move semantics, is
that it's a long time between C++03 and C++11, and there's
something to be said for move semantics yet besides what's
where C++03 was the standard, that though, C++98 was the
standard, yet then the finalizations of C99 about ILP
and the state of the 64-bit world, sort of results that
then Java8 and C++03 with at least parts of C99 is a sort
of reasonable profile of the language. Then the idea that
Java11 and C++11 and C11 all go together, more or less,
with the idea that C++ makes for some improved allocation,
references and pointers and ownership or copies and moves,
and so on, while Java11 is modern in the world of modules,
and C11 is because that's C's and the system's business,
then the syntactic sugar of later accounts like "triple
quotes" or all the various derivatives of the language
or "little languages" or "domain-specific languages",
these are considered not necessarily compelling then
as with regards to that I'm not the biggest fan of
"var" or "auto" since I see the code in front of me
and like to see its type. Then the account of "concepts"
in C++ with regards to type-safe compile-time interfaces
as a complement to "templates", I think that's a good idea,
about the commonalities in features of strongly-typed
languages like C++ and Java, where the theory of types
and type inference makes for the greatest safety in code,
according to guarantees the compiler may offer, though
there's always the PBKAC, "problem between keyboard
and chair". C++98 is the state of the world in Y2K.
Accounts of etiquette and decorum may be refreshing,
it's like Chivalry: chivalry isn't dead, it's just
curled up in the corner weakly kicking with
conversation & courtesy.
That said then it's agreeable that matters of "topicality"
are germane, relevant, apropos, for a collegiate atmosphere.
So, "C11, C++11, Java11, it goes up to 11", is a
reasonable, modern, and largely well-understood,
language profile.
Hi,
Just downloading some other person's code
I didn't do that, I wrote Hack VM for pi-WAM
from scratch, over the last 4 weeks. I came
back from holidays on end of June 2026, and now
we have end of July 2026. But its only possible
because the instruction set is very smal, like
ca. 8 functions and ca. 8 modes and ca. 8 conditions,
so its ca. 8 x 8 x 8 = 512 opcodes, each has an
A parameter and a D parameter simultaneously.
It has currently the following CPU backends:
˙- Nnow supports interleaved synchronous emulation.
˙- Now supports warp parallelism via Java platform threads.
˙- Now supports warp parallelism via Python system threads.
˙- Now supports warp parallelism via JavaScript worker threads.
˙- Note: For Python free threads are not yet fully tested.
˙- Note: For JavaScript web workers are not yet fully tested.
https://www.dogelog.ch/typtab/doclet/book/14_install/05_notes22/110_224.html
But frankly I came to encounter Hack not from
the usual university curriculum web resources,
but indirectly through a post about a Prolog
emulation of Hack, using constrained horn clauses (CHC):
Verifying Nand2Tetris Assembly
https://www.philipzucker.com/nand2tetris-chc/
The binary encoding is currently that the functions,
modes and conditions eat up a nibble (4-bit), in
total 12-bit, which I use then 10-bit for A parameter
and 10-bit for D parameter. I used AI freemium, Codex
by ChatGPT from within IntelliJ to do some fragment
code translations automatically from Java to JavaScript
or from JavaScript to Python.
Have Fun!
Bye
Johann 'Myrkraverk' Oskarsson schrieb:
As I said elsewhere, I'm not that interested in Hack, but virtual
machines and related code.˙ I mentioned another book, but now I feel
I should ask if you've also read /Crafting Interpreters/ by Robert
Nystrom?˙ I myself am still on chapter 5, so I'm still in the Java
part of the book, so I replaced comp.lang.c++ with comp.lang.java, and
am fairly excited to have a working interpreter.
This is the type of book people only properly learn from by typing in
the code themselves.˙ Just downloading some other person's code, and
running an interpreter isn't exactly a learning experience.˙ So I'm
taking my time with it, and interleaving it with my Mars adventures.
In any case, I do wish you to have fun with your own WebGPU project,
whatever that is about!
On 07/30/2026 06:49 AM, Ross Finlayson wrote:
On 07/27/2026 11:45 AM, Ross Finlayson wrote:
On 07/27/2026 11:44 AM, Ross Finlayson wrote:
On 07/27/2026 11:43 AM, Ross Finlayson wrote:
Hello, here I'll post some design notes and a panel discussion with
some
chat-bots about making some sense of the "vector-wide scalar word"
and "character machines", on commodity hardware about ubiquitous
operations.
It's considered at least tangentially relevant to comp.lang.c and
comp.lang.c++ because for example text is ubiquitous and the targets >>>>> would be low-level, while the higher-level languages would have a
same sort of patternry, and for example that libc and cstdlib are
standard, and as with regards to POSIX and Unicode and so on.
Please feel free to excuse or ignore, or comment as freely.
Thanks for reading.
[ viswath-charmaigne.txt ]
On 07/30/2026 07:05 AM, Ross Finlayson wrote:
On 07/30/2026 06:49 AM, Ross Finlayson wrote:
On 07/27/2026 11:45 AM, Ross Finlayson wrote:
On 07/27/2026 11:44 AM, Ross Finlayson wrote:
On 07/27/2026 11:43 AM, Ross Finlayson wrote:
Hello, here I'll post some design notes and a panel discussion with >>>>>> some
chat-bots about making some sense of the "vector-wide scalar word" >>>>>> and "character machines", on commodity hardware about ubiquitous
operations.
It's considered at least tangentially relevant to comp.lang.c and
comp.lang.c++ because for example text is ubiquitous and the targets >>>>>> would be low-level, while the higher-level languages would have a
same sort of patternry, and for example that libc and cstdlib are
standard, and as with regards to POSIX and Unicode and so on.
Please feel free to excuse or ignore, or comment as freely.
Thanks for reading.
[ viswath-charmaigne.txt ]
Hi,
Who exactly is the thief? Does this person
have stats in the Rogue class in dungeons
and dragons?
The conspiracy theory of a stealing of Torso VDBE,
by Rossy Boy, is probably a result of complete
ignorance of the Hack ecosystem.
Hack is a very popular computer science project,
with a couple of subprojects in hardware and
software. It goes also by the name Nand to Tetris,
and is programming language agnositic. You can do
Hack experiments in any programming language, be
it BASIC, ADA or Rust. Nobody cares.
The gist are projects like here, first to
educate yourself about Hack:
https://www.nand2tetris.org/course
And then to use Hack in different contexts:
https://www.nand2tetris.org/copy-of-talks
For didactic purposes, I used Hack for my WebGPU
experiment. I didn't even take a look at Torso
VDBE, why should I? Hack is nicely documented,
has even a book, and fusing the two 16-bit
instruction types A and D, into a single 32-bit
instruction stream, is nowhere patented.
Bye
Johann 'Myrkraverk' Oskarsson schrieb:
On 30/07/2026 2:13 AM, Ross Finlayson wrote:
https://www.theregister.com/databases/2026/07/29/after-rewriting-sqlite- >>> in-rust-turso-turns-its-sights-on-postgres/5279835
I don't much care about Rust. It's yet another Google product,
with the idea of not having exception handling, then supposedly
it's efficient and safe, yet, it's efficient by not being safe,
and safe by not being efficient. Then there's the macro/metaprogramming
front-end, which basically doesn't validate
like templates or otherwise for compile-time invariants,
that is basically like people who use string substititution instead
of object models, who all suffer injection attacks.
Personally, I like Postgres in C, and I hope it stays there.˙ I used to
maintain PL/Java, and got intimately familiar with some of the limi-
tations of the JNI interface.˙ And while there's some new Java foreign
function interface now, it doesn't replace JNI.˙ Especially for projects
that embed the JVM like PL/Java.
I haven't contributed to that project for maybe one and half decade, and
now that I'm using Java again -- a project I'll mention in another
thread --[1] I may just resume some duties in PL/Java.˙ But that's a
future adventure that may or may not happen.
So, I was going to say something about Postgres?˙ Right, I'm sure the
author of Postgres-in-Rust will run into some of the problems people
always run into when they attempt to rewrite other large projects, and
that's not learning from the prior mistakes.˙ I try to avoid that.
Some of that I learned the hard way, and some of that I learned by read-
ing the /Mythical Man Month/.˙ I don't remember the author's name, and
my physical copy is not in my current library, but I believe the author
is famous enough I don't need to mention him by name.
This latest manic episode has that in some more clinical or caring
settings, then one might wonder over the author's need to get help
or whether they're lost their mittens. In another view, though,
that's crazy-town and it's not a good place and we don't go there
any-more, population burse-scheiss-bots. Anyways here we just
generally respect people well enough to let them well alone.
I don't remote diagnose people.˙ While I don't have a medical license
to lose, I feel it's impolite to potentially mis-diagnose people over
text messages.
I have not felt very respected here in comp.lang.c.˙ I guess we must
have some different experiences in this place.˙ Who exactly is
welcoming, and a warm person?
Not to spring on you that you're wrong, it's not a conspiracy
against you, anyways as per the usual Shut Up goes out to any
of these JB, JG, PO, WM, ..., sock-puppet bots.
I'm not sure I recognize all of these initials.˙ I'm sure I'll
learn to not engage with the problem children here in comp.lang.c,
but it's been a few days, and I'm still familiarizing myself with
the regulars.
Thief.
Who exactly is the thief?˙ Does this person have stats in the Rogue
class in dungeons and dragons?
Happy C coding!
[1] Those pretend em-dashes will surely make Dan Cross even more
fictional.˙ I hope his rage isn't fictional and he'll byte every
character I type here in comp.lang.c.
Hi,
Who exactly is the thief? Does this person
have stats in the Rogue class in dungeons
and dragons?
The conspiracy theory of a stealing of Torso VDBE,
by Rossy Boy, is probably a result of complete
ignorance of the Hack ecosystem.
Hack is a very popular computer science project,
with a couple of subprojects in hardware and
software. It goes also by the name Nand to Tetris,
and is programming language agnositic. You can do
Hack experiments in any programming language, be
it BASIC, ADA or Rust. Nobody cares.
The gist are projects like here, first to
educate yourself about Hack:
https://www.nand2tetris.org/course
And then to use Hack in different contexts:
https://www.nand2tetris.org/copy-of-talks
For didactic purposes, I used Hack for my WebGPU
experiment. I didn't even take a look at Torso
VDBE, why should I? Hack is nicely documented,
has even a book, and fusing the two 16-bit
instruction types A and D, into a single 32-bit
instruction stream, is nowhere patented.
Bye
Johann 'Myrkraverk' Oskarsson schrieb:
On 30/07/2026 2:13 AM, Ross Finlayson wrote:
https://www.theregister.com/databases/2026/07/29/after-rewriting-sqlite- >>> in-rust-turso-turns-its-sights-on-postgres/5279835
I don't much care about Rust. It's yet another Google product,
with the idea of not having exception handling, then supposedly
it's efficient and safe, yet, it's efficient by not being safe,
and safe by not being efficient. Then there's the macro/metaprogramming
front-end, which basically doesn't validate
like templates or otherwise for compile-time invariants,
that is basically like people who use string substititution instead
of object models, who all suffer injection attacks.
Personally, I like Postgres in C, and I hope it stays there.˙ I used to
maintain PL/Java, and got intimately familiar with some of the limi-
tations of the JNI interface.˙ And while there's some new Java foreign
function interface now, it doesn't replace JNI.˙ Especially for projects
that embed the JVM like PL/Java.
I haven't contributed to that project for maybe one and half decade, and
now that I'm using Java again -- a project I'll mention in another
thread --[1] I may just resume some duties in PL/Java.˙ But that's a
future adventure that may or may not happen.
So, I was going to say something about Postgres?˙ Right, I'm sure the
author of Postgres-in-Rust will run into some of the problems people
always run into when they attempt to rewrite other large projects, and
that's not learning from the prior mistakes.˙ I try to avoid that.
Some of that I learned the hard way, and some of that I learned by read-
ing the /Mythical Man Month/.˙ I don't remember the author's name, and
my physical copy is not in my current library, but I believe the author
is famous enough I don't need to mention him by name.
This latest manic episode has that in some more clinical or caring
settings, then one might wonder over the author's need to get help
or whether they're lost their mittens. In another view, though,
that's crazy-town and it's not a good place and we don't go there
any-more, population burse-scheiss-bots. Anyways here we just
generally respect people well enough to let them well alone.
I don't remote diagnose people.˙ While I don't have a medical license
to lose, I feel it's impolite to potentially mis-diagnose people over
text messages.
I have not felt very respected here in comp.lang.c.˙ I guess we must
have some different experiences in this place.˙ Who exactly is
welcoming, and a warm person?
Not to spring on you that you're wrong, it's not a conspiracy
against you, anyways as per the usual Shut Up goes out to any
of these JB, JG, PO, WM, ..., sock-puppet bots.
I'm not sure I recognize all of these initials.˙ I'm sure I'll
learn to not engage with the problem children here in comp.lang.c,
but it's been a few days, and I'm still familiarizing myself with
the regulars.
Thief.
Who exactly is the thief?˙ Does this person have stats in the Rogue
class in dungeons and dragons?
Happy C coding!
[1] Those pretend em-dashes will surely make Dan Cross even more
fictional.˙ I hope his rage isn't fictional and he'll byte every
character I type here in comp.lang.c.
Hi,
This was archived on Jul 9, 2026:
11.4 Giga Lips with a Budget Laptop https://github.com/Jean-Luc-Picard-2021/gigabudget
Still, Jul 29, Rossy Boy halucinates accusations:
Ross Finlayson schrieb:
.. bla bla goto bla bla ..
Stupid gangster:˙ teamsters are a union.
In the trades, not the steals, ....
Woa! Thats now 20 days of brain desease,
and not understanding the meaning and implications.
Even not understand pi-WAM has Hack VM backend.
But its all opensource. Bravo Rossy Boy, you are
champion in brainlessness and lazyness of
a idiot usenet troll.
Bye
Johann 'Myrkraverk' Oskarsson schrieb:
On 28/07/2026 2:43 AM, Ross Finlayson wrote:
Hello, here I'll post some design notes and a panel discussion with some >>> chat-bots about making some sense of the "vector-wide scalar word"
and "character machines", on commodity hardware about ubiquitous
operations.
It's considered at least tangentially relevant to comp.lang.c and
comp.lang.c++ because for example text is ubiquitous and the targets
would be low-level, while the higher-level languages would have a
same sort of patternry, and for example that libc and cstdlib are
standard, and as with regards to POSIX and Unicode and so on.
Please feel free to excuse or ignore, or comment as freely.
Thanks for reading.
Are you generating all of your code via LLMs?˙ Rest assured,
the LLM generated code will have subtle and sometimes not so subtle
bugs.
Happy bughunting!
Hi,
He uses FIFO, and DMA and Noc:
Getting peak TOPS on a Ryzen AI 7 350 NPU https://destevez.net/2026/05/getting-peak-tops-on-a-ryzen-ai-7-350-npu/
But lets say whether its FIFO or FILO
isn't so important his used cases are,
what is now found in my library(furryhaze)
for GPU, namely the very basic:
/**
˙* test_gpu_comp_start(W, K): internal only
˙* The predicate succeeds. As a side effect it
˙* starts the ă-WAM W with K warps.
˙*/
function test_gpu_comp_start(args)
/**
˙* test_gpu_comp_join(W, P): internal only
˙* The predicate succeeds in P with a new promise
˙* that waits for the ă-WAM W to finish.
˙*/
function test_gpu_comp_join(args)
A GPU interface, via the command processor
for example of WebGPU, does the above
synchronization for you.
In the NPU example he does everything
low level, with Python IRON an stuff:
"Since the main way to achieve synchronization
within the IRON framework is by doing data
movement with object FIFOs, I?m sending a
dummy uint32 value as some sort of
synchronization token.
Waiting for all the kernels to finish is
trickier. The object FIFOs support a join
pattern in which an object FIFO consumes an
object from each of multiple object FIFOs,
concatenates these objects and produces the
concatenated object as a result.
Etc.."
Getting peak TOPS on a Ryzen AI 7 350 NPU https://destevez.net/2026/05/getting-peak-tops-on-a-ryzen-ai-7-350-npu/
So Daniel Est‚vez Scientific & Technical
Amateur Radio, gives a nice glimpse into an
NPU, I have not yet publicitly released
my library(furryhaze), since its still in
testing. Maybe take another week or so,
still I have ironed out all corners,
for example the new gpu_comp_start and
gpu_comp_join works fine on may desktop
AI laptops, but I have still a bug on
my iPad AI tablet, on the Redmi AI phone,
also chokes on a test case.
Bye
Mild Shock schrieb:
Hi,
This was archived on Jul 9, 2026:
11.4 Giga Lips with a Budget Laptop
https://github.com/Jean-Luc-Picard-2021/gigabudget
Still, Jul 29, Rossy Boy halucinates accusations:
Ross Finlayson schrieb:
.. bla bla goto bla bla ..
Stupid gangster:˙ teamsters are a union.
In the trades, not the steals, ....
Woa! Thats now 20 days of brain desease,
and not understanding the meaning and implications.
Even not understand pi-WAM has Hack VM backend.
But its all opensource. Bravo Rossy Boy, you are
champion in brainlessness and lazyness of
a idiot usenet troll.
Bye
Johann 'Myrkraverk' Oskarsson schrieb:
On 28/07/2026 2:43 AM, Ross Finlayson wrote:
Hello, here I'll post some design notes and a panel discussion with
some
chat-bots about making some sense of the "vector-wide scalar word"
and "character machines", on commodity hardware about ubiquitous
operations.
It's considered at least tangentially relevant to comp.lang.c and
comp.lang.c++ because for example text is ubiquitous and the targets
would be low-level, while the higher-level languages would have a
same sort of patternry, and for example that libc and cstdlib are
standard, and as with regards to POSIX and Unicode and so on.
Please feel free to excuse or ignore, or comment as freely.
Thanks for reading.
Are you generating all of your code via LLMs?˙ Rest assured,
the LLM generated code will have subtle and sometimes not so subtle
bugs.
Happy bughunting!
Hi,
Tablets and phone are more annoying to
use with WebGPU. The usual browsers don't
have a Chrome DevTools panel integrated,
so that one could do JavaScript Debugging
directly on the device. Instead one has to
use a desktop machine, and connect the
device via UBS-C , and start a Chrome
Browser there . And then start a Chrome
DevTools panel alone, that is pair with
the device, via UBS-C cable. So this way
I already see where it crashes on the
tablets and phone:
await output.mapAsync(GPUMapMode.READ)
Unhandled Promise Rejection: OperationError
The above is the error that one can re-produce
already here with this test:
11.4 Giga Lips with a Budget Laptop https://github.com/Jean-Luc-Picard-2021/gigabudget
Not sure what exactly happens. Maybe
a form of timeout or device lost, that the
primitive HTML / JavaScript doesn't handle
gracefully yet. Maybe redimensioning the
test, so that it consumes less time would
help. Who knows? Will see. For production
use of a GPU integration I have to anyway
provide work slicing it seems.
Bye
Mild Shock schrieb:
Hi,
He uses FIFO, and DMA and Noc:
Getting peak TOPS on a Ryzen AI 7 350 NPU
https://destevez.net/2026/05/getting-peak-tops-on-a-ryzen-ai-7-350-npu/
But lets say whether its FIFO or FILO
isn't so important his used cases are,
what is now found in my library(furryhaze)
for GPU, namely the very basic:
/**
˙˙* test_gpu_comp_start(W, K): internal only
˙˙* The predicate succeeds. As a side effect it
˙˙* starts the ă-WAM W with K warps.
˙˙*/
function test_gpu_comp_start(args)
/**
˙˙* test_gpu_comp_join(W, P): internal only
˙˙* The predicate succeeds in P with a new promise
˙˙* that waits for the ă-WAM W to finish.
˙˙*/
function test_gpu_comp_join(args)
A GPU interface, via the command processor
for example of WebGPU, does the above
synchronization for you.
In the NPU example he does everything
low level, with Python IRON an stuff:
"Since the main way to achieve synchronization
within the IRON framework is by doing data
movement with object FIFOs, I?m sending a
dummy uint32 value as some sort of
synchronization token.
Waiting for all the kernels to finish is
trickier. The object FIFOs support a join
pattern in which an object FIFO consumes an
object from each of multiple object FIFOs,
concatenates these objects and produces the
concatenated object as a result.
Etc.."
Getting peak TOPS on a Ryzen AI 7 350 NPU
https://destevez.net/2026/05/getting-peak-tops-on-a-ryzen-ai-7-350-npu/
So Daniel Est‚vez Scientific & Technical
Amateur Radio, gives a nice glimpse into an
NPU, I have not yet publicitly released
my library(furryhaze), since its still in
testing. Maybe take another week or so,
still I have ironed out all corners,
for example the new gpu_comp_start and
gpu_comp_join works fine on may desktop
AI laptops, but I have still a bug on
my iPad AI tablet, on the Redmi AI phone,
also chokes on a test case.
Bye
Mild Shock schrieb:
Hi,
This was archived on Jul 9, 2026:
11.4 Giga Lips with a Budget Laptop
https://github.com/Jean-Luc-Picard-2021/gigabudget
Still, Jul 29, Rossy Boy halucinates accusations:
Ross Finlayson schrieb:
.. bla bla goto bla bla ..
Stupid gangster:˙ teamsters are a union.
In the trades, not the steals, ....
Woa! Thats now 20 days of brain desease,
and not understanding the meaning and implications.
Even not understand pi-WAM has Hack VM backend.
But its all opensource. Bravo Rossy Boy, you are
champion in brainlessness and lazyness of
a idiot usenet troll.
Bye
Johann 'Myrkraverk' Oskarsson schrieb:
On 28/07/2026 2:43 AM, Ross Finlayson wrote:
Hello, here I'll post some design notes and a panel discussion with >>>>> some
chat-bots about making some sense of the "vector-wide scalar word"
and "character machines", on commodity hardware about ubiquitous
operations.
It's considered at least tangentially relevant to comp.lang.c and
comp.lang.c++ because for example text is ubiquitous and the targets >>>>> would be low-level, while the higher-level languages would have a
same sort of patternry, and for example that libc and cstdlib are
standard, and as with regards to POSIX and Unicode and so on.
Please feel free to excuse or ignore, or comment as freely.
Thanks for reading.
Are you generating all of your code via LLMs?˙ Rest assured,
the LLM generated code will have subtle and sometimes not so subtle
bugs.
Happy bughunting!
Hi,
Looking at the floor plan of a NPU:
Getting peak TOPS on a Ryzen AI 7 350 NPU https://destevez.net/2026/05/getting-peak-tops-on-a-ryzen-ai-7-350-npu/
It seems to me comms between tiles takes
at least Manhattan Distance or L1 Norm time,
if there is no comms congestion
But how does a packet travel? This way:
+----E
|
|
S
Or this way, from start S to end E:
˙˙ +-E
˙ +
˙+
S
And what does the chip do if there is
traffic congestion? Some papers are
here, possibly an old problem giving
that processor "cubes" are nothing new.
But a "cube" would be 3D and not 2D.
This paper is old from 2007 or so:
Routing Algorithms for 2D NoC Architectures http://cva.stanford.edu/classes/ee382c/research/2DRouting.pdf
Bye
On 8/1/2026 5:47 PM, Mild Shock wrote:building vector fields, etc.... And yes I use textures for some input
Hi,[...]
Chris M. Thomasson can ask 100 more questions.
I will happily answer them. But maybe I should
make a Wiki to explain the ever same things:
But, I still don't know what you main goal is?The goal is "Prolog inferencing"
It has textures to work with in the pipeline.I don't need textures for "Prolog inferencing"
98 more questions to go, don't give up!
Fwiw, I have several compute shaders that do what I want. Mainly
For instance, this is 100% wait free.
void add_hit(ct_plane2d plane, vec2 p, vec3 weight)
{
vec2 uv = ct_plane2d_unproject(plane, p);
ivec2 px = ivec2(uv * u_resolution);
if (px.x >= 0 && px.x < int(u_resolution.x) &&
px.y >= 0 && px.y < int(u_resolution.y))
{
imageAtomicAdd(accum_r, px, weight.r);
imageAtomicAdd(accum_g, px, weight.g);
imageAtomicAdd(accum_b, px, weight.b);
imageAtomicAdd(accum_hits, px, 1.0f);
}
}
Notice how I separated my accumulation buffer into different textures?alpha / hit counter
layout(binding = 0, r32f) uniform coherent image2D accum_r;
layout(binding = 1, r32f) uniform coherent image2D accum_g;
layout(binding = 2, r32f) uniform coherent image2D accum_b;
layout(binding = 3, r32f) uniform coherent image2D accum_hits; //
Works great and runs really fast.
On 7/29/2026 2:21 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 29/07/2026 5:15 PM, Mild Shock wrote:
Hi,
Confused rossy boy is confused. We are
not building a stupid web server, where
a listener thread spawns service threads,
and to avoid malloc and free, reuses
a pool, or some shitty fork join framework.
The producer and consumer example I posted
elsewhere archived a dataflow without
malloc and free of threads. You are miles
away from what we are doing here.
Why not?˙ Isn't this comp.lang.c?˙ And isn't that exactly how
CivetWeb works internally?
Have you never built your own web
sever in C?˙ Not even with CivetWeb?˙ It's really easy!˙ You
only need to implement a callback or two.
Implementing a callback or two in a preexisting system is not creating
one from scratch.
Hi,
If only the fucking moron Chris M. Thomasson would
stop spamming his nonsense, he doesn't listen at
all. Problem, he cannot read, he knows nothing.
Its very common that compute shaders can block,
when they are used for General Purpose computation
on GPUs (GPGPU). If only he would pull out his
finger from his asshole, and stop thinking in his
WebGL legacy code stash nonsense. Even the
Cerebras Waver has blocking:
"Cerebras Software Language (CSL), send_color
and recv_color are parameters passed to tile
programs to manage data routing and virtual
channels (called colors) across processing
elements (PEs) on the wafer
Yes, both send and receive operations can block
on a Cerebras Processing Element (PE), primarily
due to the system's hardware-enforced backpressure
mechanism. Because the Cerebras Wafer-Scale Engine
(WSE) relies on a fine-grained,
dataflow-driven architecture, blocking prevents
data loss when hardware resources are
fully saturated."
Blocking and Unblocking https://sdk.cerebras.ai/computing-with-cerebras#blocking-and-unblocking
Chris M. Thomasson is an annoyance and an idiot.
He is a total waste of time. And represents those
people who cannot use their brain.
On 8/2/2026 2:37 PM, Mild Shock wrote:[...]
I don't think you have coded compute shaders before? If so, cool, but wow.
[...]
On 8/2/2026 2:37 PM, Mild Shock wrote:
Hi,
If only the fucking moron Chris M. Thomasson would
stop spamming his nonsense, he doesn't listen at
all. Problem, he cannot read, he knows nothing.
Its very common that compute shaders can block,
when they are used for General Purpose computation
on GPUs (GPGPU). If only he would pull out his
finger from his asshole, and stop thinking in his
WebGL legacy code stash nonsense. Even the
Cerebras Waver has blocking:
"Cerebras Software Language (CSL), send_color
and recv_color are parameters passed to tile
programs to manage data routing and virtual
channels (called colors) across processing
elements (PEs) on the wafer
Yes, both send and receive operations can block
on a Cerebras Processing Element (PE), primarily
due to the system's hardware-enforced backpressure
mechanism. Because the Cerebras Wafer-Scale Engine
(WSE) relies on a fine-grained,
dataflow-driven architecture, blocking prevents
data loss when hardware resources are
fully saturated."
Blocking and Unblocking
https://sdk.cerebras.ai/computing-with-cerebras#blocking-and-unblocking
Strive to never make a compute shader wait on something, like an empty condition of a queue, stack.
Chris M. Thomasson is an annoyance and an idiot.
He is a total waste of time. And represents those
people who cannot use their brain.
I don't think you have coded compute shaders before? If so, cool, but wow.
[...]
On 8/2/2026 2:37 PM, Mild Shock wrote:
Hi,
If only the fucking moron Chris M. Thomasson would
stop spamming his nonsense, he doesn't listen at
all. Problem, he cannot read, he knows nothing.
Its very common that compute shaders can block,
when they are used for General Purpose computation
on GPUs (GPGPU). If only he would pull out his
finger from his asshole, and stop thinking in his
WebGL legacy code stash nonsense. Even the
Cerebras Waver has blocking:
"Cerebras Software Language (CSL), send_color
and recv_color are parameters passed to tile
programs to manage data routing and virtual
channels (called colors) across processing
elements (PEs) on the wafer
Yes, both send and receive operations can block
on a Cerebras Processing Element (PE), primarily
due to the system's hardware-enforced backpressure
mechanism. Because the Cerebras Wafer-Scale Engine
(WSE) relies on a fine-grained,
dataflow-driven architecture, blocking prevents
data loss when hardware resources are
fully saturated."
Blocking and Unblocking
https://sdk.cerebras.ai/computing-with-cerebras#blocking-and-unblocking
Strive to never make a compute shader wait on something, like an empty condition of a queue, stack.
Chris M. Thomasson is an annoyance and an idiot.
He is a total waste of time. And represents those
people who cannot use their brain.
I don't think you have coded compute shaders before? If so, cool, but wow.
[...]
11.4 Giga Lips with a Budget Laptop https://github.com/Jean-Luc-Picard-2021/gigabudget
Hi,
You are a moron. In WebGPU computer sharers
are tasks not hardware kernels. Forget your
WebGL nonsense cookbooks.
WebGPU is much more elastic.
You are just a moron.
Bye
P.S.: Take this example, I don't have 4096 kernels:
11.4 Giga Lips with a Budget Laptop https://github.com/Jean-Luc-Picard-2021/gigabudget
Still it runs, how is this done? The Ryzen has
only around 512 kernels. Newer Ryzen havae 1024
kernels. This is till below 4096 logical threads.
So how is it done?
Chris M. Thomasson schrieb:
On 8/2/2026 2:37 PM, Mild Shock wrote:
Hi,
If only the fucking moron Chris M. Thomasson would
stop spamming his nonsense, he doesn't listen at
all. Problem, he cannot read, he knows nothing.
Its very common that compute shaders can block,
when they are used for General Purpose computation
on GPUs (GPGPU). If only he would pull out his
finger from his asshole, and stop thinking in his
WebGL legacy code stash nonsense. Even the
Cerebras Waver has blocking:
"Cerebras Software Language (CSL), send_color
and recv_color are parameters passed to tile
programs to manage data routing and virtual
channels (called colors) across processing
elements (PEs) on the wafer
Yes, both send and receive operations can block
on a Cerebras Processing Element (PE), primarily
due to the system's hardware-enforced backpressure
mechanism. Because the Cerebras Wafer-Scale Engine
(WSE) relies on a fine-grained,
dataflow-driven architecture, blocking prevents
data loss when hardware resources are
fully saturated."
Blocking and Unblocking
https://sdk.cerebras.ai/computing-with-cerebras#blocking-and-unblocking
Strive to never make a compute shader wait on something, like an empty
condition of a queue, stack.
Chris M. Thomasson is an annoyance and an idiot.
He is a total waste of time. And represents those
people who cannot use their brain.
I don't think you have coded compute shaders before? If so, cool, but
wow.
[...]
Hi,
A nosomatic AI chirurgeon is a halfling student
of sickness, and a master of the ebb and flow of
the energies of life and death of data packets.
He is a air bender, water bender and earth bender
in one person, using OpenVINO to juggle with
CPU, GPU and NPU.
Last but not least he can freely switch between
symbolic and neural representation of knowledge
forms, there is no abyss for him.
Bye
Hi,
This was archived on Jul 9, 2026:
11.4 Giga Lips with a Budget Laptop https://github.com/Jean-Luc-Picard-2021/gigabudget
Still today on Aug 03, 2026, the usenet
community still struggles with the experiment,
doesn't know the meaning and implications,
especially clueless about 4096 shaders and
modern GPU elasticity. Woa! Thats impressive.
Especially Chris M. Thomasson has a still ongoing
hard time with this little WebGPU experiment.
Bye
Mild Shock schrieb:
Hi,
You are a moron. In WebGPU computer sharers
are tasks not hardware kernels. Forget your
WebGL nonsense cookbooks.
WebGPU is much more elastic.
You are just a moron.
Bye
P.S.: Take this example, I don't have 4096 kernels:
11.4 Giga Lips with a Budget Laptop
https://github.com/Jean-Luc-Picard-2021/gigabudget
Still it runs, how is this done? The Ryzen has
only around 512 kernels. Newer Ryzen havae 1024
kernels. This is till below 4096 logical threads.
So how is it done?
Chris M. Thomasson schrieb:
On 8/2/2026 2:37 PM, Mild Shock wrote:
Hi,Strive to never make a compute shader wait on something, like an
If only the fucking moron Chris M. Thomasson would
stop spamming his nonsense, he doesn't listen at
all. Problem, he cannot read, he knows nothing.
Its very common that compute shaders can block,
when they are used for General Purpose computation
on GPUs (GPGPU). If only he would pull out his
finger from his asshole, and stop thinking in his
WebGL legacy code stash nonsense. Even the
Cerebras Waver has blocking:
"Cerebras Software Language (CSL), send_color
and recv_color are parameters passed to tile
programs to manage data routing and virtual
channels (called colors) across processing
elements (PEs) on the wafer
Yes, both send and receive operations can block
on a Cerebras Processing Element (PE), primarily
due to the system's hardware-enforced backpressure
mechanism. Because the Cerebras Wafer-Scale Engine
(WSE) relies on a fine-grained,
dataflow-driven architecture, blocking prevents
data loss when hardware resources are
fully saturated."
Blocking and Unblocking
https://sdk.cerebras.ai/computing-with-cerebras#blocking-and-unblocking >>>
empty condition of a queue, stack.
Chris M. Thomasson is an annoyance and an idiot.
He is a total waste of time. And represents those
people who cannot use their brain.
I don't think you have coded compute shaders before? If so, cool, but
wow.
[...]
Hello, here I'll post some design notes and a panel discussion with some chat-bots about making some sense of the "vector-wide scalar word"
and "character machines", on commodity hardware about ubiquitous
operations.
It's considered at least tangentially relevant to comp.lang.c and comp.lang.c++ because for example text is ubiquitous and the targets
would be low-level, while the higher-level languages would have a
same sort of patternry, and for example that libc and cstdlib are
standard, and as with regards to POSIX and Unicode and so on.
Please feel free to excuse or ignore, or comment as freely.
Thanks for reading.
Hi,
I even don't remember exactly why I landed
in comp.theory. A yes, because Rossy Boy,
was hooked on SIMD and didn't understand Hack.
But the Hack work, rather belongs to my
Alma Mater Zurich and my personal heros, Gutnecht
and Wirth, who wrote a one pass Modula
compiler during some christmas holidays,
back then when I was student. Not sure
whether the Ljubljana School can do that,
when I read this here:
Finite Algebraic Effects as dicts and such https://www.philipzucker.com/bdd_term_alg_effects/
I only find gibberish like:
- ?Data? is somehow less mysterious to me
˙ than ?computation?.˙ [..] I don?t even
˙ know what ?computation? really is
- In temporal logic, there is a logic CTL
˙ which talks about computation trees.
- Algerbaic (LoL) effects is almost a complete
˙ hackery abuse of the notion of arity
˙ and that?s neat.
- Then there are 10^10 etc vectors which
˙ show up if you discretize 3d/4d space. [..]
˙ or reinforcement learning.
- Etc..
WTF is this guy smoking? I mean he even
doesn't uses math notation, only posts
Python code fragments … go go,
possibly a Python brain damage.
On 04/08/2026 2:14 AM, Mild Shock wrote:
Hi,
I even don't remember exactly why I landed
in comp.theory. A yes, because Rossy Boy,
was hooked on SIMD and didn't understand Hack.
But the Hack work, rather belongs to my
Alma Mater Zurich and my personal heros, Gutnecht
and Wirth, who wrote a one pass Modula
That's interesting.˙ Have you read /Software Engineering
with Modula-2 and Ada/ (1984) by Richard Wiener and Richard
Sincovec?˙ I have it on my shelf, and haven't gotten to read
it yet.
compiler during some christmas holidays,
back then when I was student. Not sure
whether the Ljubljana School can do that,
when I read this here:
Finite Algebraic Effects as dicts and such
https://www.philipzucker.com/bdd_term_alg_effects/
I only find gibberish like:
- ?Data? is somehow less mysterious to me
˙˙ than ?computation?.˙ [..] I don?t even
˙˙ know what ?computation? really is
Computation is at the core just a calculation.˙ Humans
used to do this, and there's a good documentary about it
titled /Hidden Figures/.˙ I assume everyone here has seen
it.
- In temporal logic, there is a logic CTL
˙˙ which talks about computation trees.
- Algerbaic (LoL) effects is almost a complete
˙˙ hackery abuse of the notion of arity
˙˙ and that?s neat.
Are you using /algebraic effects/ when playing League
of Legends?˙ I tried it once, but discovered it's a
gameplay that doesn't appeal to me.˙ I didn't think to
use /algebraic effects/ in it.
- Then there are 10^10 etc vectors which
˙˙ show up if you discretize 3d/4d space. [..]
˙˙ or reinforcement learning.
I don't know why you have that many vectors visiting,
but please treat them with hospitality according to
Zeus' laws.
- Etc..
WTF is this guy smoking? I mean he even
doesn't uses math notation, only posts
Python code fragments … go go,
possibly a Python brain damage.
Or he just works in the ministry of silly walks?
Enjoy!
Hi,
I even don't remember exactly why I landed
in comp.theory. A yes, because Rossy Boy,
was hooked on SIMD and didn't understand Hack.
But the Hack work, rather belongs to my
Alma Mater Zurich and my personal heros, Gutnecht
and Wirth, who wrote a one pass Modula
compiler during some christmas holidays,
back then when I was student. Not sure
whether the Ljubljana School can do that,
when I read this here:
Finite Algebraic Effects as dicts and such https://www.philipzucker.com/bdd_term_alg_effects/
I only find gibberish like:
- ?Data? is somehow less mysterious to me
˙ than ?computation?.˙ [..] I don?t even
˙ know what ?computation? really is
- In temporal logic, there is a logic CTL
˙ which talks about computation trees.
- Algerbaic (LoL) effects is almost a complete
˙ hackery abuse of the notion of arity
˙ and that?s neat.
- Then there are 10^10 etc vectors which
˙ show up if you discretize 3d/4d space. [..]
˙ or reinforcement learning.
- Etc..
WTF is this guy smoking? I mean he even
doesn't uses math notation, only posts
Python code fragments … go go,
possibly a Python brain damage.
But still less sever than Rossy Boys.
Bye
Ross Finlayson schrieb:
Hello, here I'll post some design notes and a panel discussion with some
chat-bots about making some sense of the "vector-wide scalar word"
and "character machines", on commodity hardware about ubiquitous
operations.
It's considered at least tangentially relevant to comp.lang.c and
comp.lang.c++ because for example text is ubiquitous and the targets
would be low-level, while the higher-level languages would have a
same sort of patternry, and for example that libc and cstdlib are
standard, and as with regards to POSIX and Unicode and so on.
Please feel free to excuse or ignore, or comment as freely.
Thanks for reading.
I don't think you have coded compute shaders before? If so, cool,
but wow.
Hi,
I found that this here:
˙˙˙ public final static class RendezVous {
˙˙˙˙˙˙˙ private final Semaphore head = new Semaphore(0);
˙˙˙˙˙˙˙ private final Semaphore tail = new Semaphore(1);
˙˙˙˙˙˙˙ private Object data;
˙˙˙˙˙˙˙ public void put(Object data) throws InterruptedException {
˙˙˙˙˙˙˙˙˙˙˙ tail.acquire();
˙˙˙˙˙˙˙˙˙˙˙ this.data = data;
˙˙˙˙˙˙˙˙˙˙˙ head.release();
˙˙˙˙˙˙˙ }
˙˙˙˙˙˙˙ public Object take() throws InterruptedException {
˙˙˙˙˙˙˙˙˙˙˙ Object res;
˙˙˙˙˙˙˙˙˙˙˙ head.acquire();
˙˙˙˙˙˙˙˙˙˙˙ res = data;
˙˙˙˙˙˙˙˙˙˙˙ tail.release();
˙˙˙˙˙˙˙˙˙˙˙ return res;
˙˙˙˙˙˙˙ }
˙˙˙ }
Is almost as fast as ArrayBlockingQueue(4),
in a producer worker consumer scenario.
So I considering using the above for the
pi-WAM channels. It would be also closer
to pi-calculus by Robin Milner.
Bye
Johann 'Myrkraverk' Oskarsson schrieb:
On 04/08/2026 2:14 AM, Mild Shock wrote:
Hi,
I even don't remember exactly why I landed
in comp.theory. A yes, because Rossy Boy,
was hooked on SIMD and didn't understand Hack.
But the Hack work, rather belongs to my
Alma Mater Zurich and my personal heros, Gutnecht
and Wirth, who wrote a one pass Modula
That's interesting.˙ Have you read /Software Engineering
with Modula-2 and Ada/ (1984) by Richard Wiener and Richard
Sincovec?˙ I have it on my shelf, and haven't gotten to read
it yet.
compiler during some christmas holidays,
back then when I was student. Not sure
whether the Ljubljana School can do that,
when I read this here:
Finite Algebraic Effects as dicts and such
https://www.philipzucker.com/bdd_term_alg_effects/
I only find gibberish like:
- ?Data? is somehow less mysterious to me
˙˙ than ?computation?.˙ [..] I don?t even
˙˙ know what ?computation? really is
Computation is at the core just a calculation.˙ Humans
used to do this, and there's a good documentary about it
titled /Hidden Figures/.˙ I assume everyone here has seen
it.
- In temporal logic, there is a logic CTL
˙˙ which talks about computation trees.
- Algerbaic (LoL) effects is almost a complete
˙˙ hackery abuse of the notion of arity
˙˙ and that?s neat.
Are you using /algebraic effects/ when playing League
of Legends?˙ I tried it once, but discovered it's a
gameplay that doesn't appeal to me.˙ I didn't think to
use /algebraic effects/ in it.
- Then there are 10^10 etc vectors which
˙˙ show up if you discretize 3d/4d space. [..]
˙˙ or reinforcement learning.
I don't know why you have that many vectors visiting,
but please treat them with hospitality according to
Zeus' laws.
- Etc..
WTF is this guy smoking? I mean he even
doesn't uses math notation, only posts
Python code fragments … go go,
possibly a Python brain damage.
Or he just works in the ministry of silly walks?
Enjoy!
On 8/2/2026 5:08 PM, Mild Shock wrote:
[...]
***I don't think** you have coded compute
shaders before? If so, cool, but wow.
Never mind. You are too hostile. Not worth it. Sorry. Plonk.
Hi,
You are not correctly thinking.
I am not using WebGL. I use WebGPU.
Spinning is perfectly fine. I will
soon give proof. Meanwhile enjoy
this use case, so that you understand
the goal of Prolog "inferencing" for
a simple example:
"We try to find 0xCAFFEE in enumerating 4
6-bit digits and the baseline is Dogelog
Player VM in a browser. The CPU backend
with 64 logical threads is already 20
times faster, partly due to its 32-bit
specialization. The GPU backend with
4096 logical threads boosts a further
factor of 7 times."
GPU Backend: Find 0xCAFFEE with ă-WAM
https://medium.com/2989/8890efd3503c
If you don't understand the goal, and
the benefits of the goal, all your
thinking will anyways be incorrect.
Bye
Chris M. Thomasson schrieb:
On 8/2/2026 5:08 PM, Mild Shock wrote:
[...]
***I don't think** you have coded compute shaders before? If so,
cool, but wow.
Never mind. You are too hostile. Not worth it. Sorry. Plonk.
So, I am using dirextc12 and modern opengl for my
compute shaders right now. GLSL as my lang. I need
to provide some state for them to work
with. Aka, textures and uniforms.
Any luck? Its fun to see how many work
items were completed when the mutex was contended...
Hi,
Why do you even open your mouth if you
don't use WebGPU / WGSL? This beyond my
comprehension. OpenGL was phased out by
Apple years ago. It only lives on some
linux boxes. Also you probably don't use
an AI Laptop. Just make a simple calculation,
if you have 512 Kernels, and oversubscribe
4096 logical threads. Then each Kernel runs
4 logical threads. If one of these 4 logical
threads spins, how much performance is lost?
25% of this single kernel. And there are
still 511 Kernels. Spinning is totally fine,
thats why WGSL provides CAS, and not some
waitlists. The kernels are the wait lists itself
doing the following when spinning:
NOP
NOP
NOP
Etc..
Until the a condition is met. You even don't
need backoff, because you cannot pause. The
only pause you can do is a barrier.
But if the condition is not met while the
barrier is met, what will you do?
Bye
Chris M. Thomasson schrieb:
So, I am using dirextc12 and modern opengl for my compute shaders
right˙ now. GLSL as my lang. I need to provide some state for them to
work with. Aka, textures and uniforms.
Hi,
I you use atomicAdd() you have the same friction
as if you use Queue put() or take(). There is
no difference. The only difference is unbounded
versus bounded. I tried to explain that like
100-times already. Your comment here:
Any luck? Its fun to see how many work
items were completed when the mutex was contended...
Says to me you don't understand queues. They
are not mutexes. Because you don't understand
queues, you also don't understand OpenMP
parallelism and patterns such as producer,
workers, consumer. Contention is usually minimal,
the workers just fetch work items from the
producer, and then do some workload. And
then hand the result to the consumer. If
you use atomicAdd() you have the same friction
as if you use Queue put() or take(). There
is no difference. The only difference is unbounded
versus bounded. I tried to explain that[...]
On 8/3/2026 1:37 PM, Mild Shock wrote:
Hi,
I you use atomicAdd() you have the same friction
as if you use Queue put() or take(). There is
no difference. The only difference is unbounded
versus bounded. I tried to explain that like
100-times already. Your comment here:
Any luck? Its fun to see how many work
items were completed when the mutex was contended...
Says to me you don't understand queues. They
are not mutexes. Because you don't understand
queues, you also don't understand OpenMP
parallelism and patterns such as producer,
workers, consumer. Contention is usually minimal,
the workers just fetch work items from the
producer, and then do some workload. And
then hand the result to the consumer. If
you use atomicAdd() you have the same friction
as if you use Queue put() or take(). There
is no difference. The only difference is unbounded
versus bounded. I tried to explain that[...]
lol. I forgot to add you to my killfile. Damn it! Anyway, I know all
about them. Sigh. Peace be with you.
| Sysop: | Tetrazocine |
|---|---|
| Location: | Melbourne, VIC, Australia |
| Users: | 12 |
| Nodes: | 8 (0 / 8) |
| Uptime: | 201:38:01 |
| Calls: | 220 |
| Files: | 21,513 |
| Messages: | 83,420 |