372000+ entries in 0.236s
mircea_popescu: ascii_field just
think of
this beautiful illustration of doing >
thinking. just like you had your
thoughts figured out by someone else, so will WE have
these figured out by someone else. endlessly.
mircea_popescu: don't
tell me if we were in 1715 you'd have been
the sort
that actually distinguished
the slaves.
mircea_popescu: doesn't matter. did anyone buy's 21co's PREVIOUS potato, when it was called neobee or w/e
the shit it was called ?
mircea_popescu: if only we had a cardano ready
to ship so
this discussion could double as marketing for
the s.nsa next product.
ascii_field: (one rung of
the ring ought
to be
the size of
the r/w burst for
the dram)
mircea_popescu: the motherboard has some memory on-board for
the indexing and internal kitchening, and otherwise you maximize
the strengths of ddr while escaping all drawbacks
ascii_field worked
this out in some detail, if anybody 'ever asks'
mircea_popescu: the whole
txn memory mapping could be a soac
thing, and you just plug memory sticks into it which each becomes a ring.
mircea_popescu: this
thing, incidentally, is where we would immensely benefit from actually having silicon.
mircea_popescu: ascii_field quote as
to "opened my eyes", i know where
the concrete hole is from
ascii_field: the one with 'what makes you sorry lot
think you get seats in heaven?
there's a 20 metre cube fermentation
tank...' or sumthinglikethat
ascii_field: so now i have a bit moar sympathy for
the pebble folk
assbot: Logged on 28-11-2015 17:21:16; mircea_popescu: ascii_field you misunderstand
the "play with pebbles". it's doing stuff like playing angry birds on iphone.
ascii_field: (interdependent shitweb of links
to 'inputs' and 'outputs')
ascii_field: the way
the existing
turd stores
tx is untenable
jurov: also, unless whole
thing is rewritten, itx consists of 2 vectors (inputs, outputs) with several objects and you want
to remove all or none
ascii_field: aha
this was described in agonizing detail in
the original mempool
thread
mircea_popescu: there's a lot of work can be done
to minimize wastage in
this, but
the fundamental problem is solved.
mircea_popescu: anyway, re
the <jurov> lol part :
there's a very obvious optimization where you go a) i want
to fit
this struct ; b) is
there space ? if yes fit it if no c) kill
the lowest per-byte value struct in
there go back
to a
jurov: ascii_field: what do you
think about slab allocator? i know it adds a layer of complication, but may be worth it
ascii_field: whole reason i'm at
the console
to begin with...
ascii_field: which happens
to be what i'm implementing right at
this very moment
ascii_field: or rather, fixed heap size variant
thereof
ascii_field: mircea_popescu just described
traditional malloc
mircea_popescu: or w/e memory space one wants
to allocatge
to
the "mempool"
jurov: you want 500M
transactions?
mircea_popescu: but a firm guarantee can be offered
that for as long as you allocate structs smaller
than n, you wioll be able
to fit
them.
mircea_popescu: how
to do either of
these is a problem of optimization outside
the scope of
this discussion.
mircea_popescu: whenever you want
to add something, you put it in
the available hole. if you don't have a hole you kill something until you do.
mircea_popescu: you separately keep an index of what structures you have in
there (offset, length).
mircea_popescu: n bytes are allocated
to "ring buffer", from offset k
to offset k+n.
the convention of reading
this is
that structures started at k+n-m
that are m+p bytes long continue from k+n
to k and all
the way
to k+p
jurov: throw out
two, end up with wasted mem
jurov: and
then a medium
txfee
transaction comes you,
to
throw one free
tx out
to make space.. but it won§t fit
mircea_popescu: actually, i suppose i should go into detail as we have no good reason
to suspect we actually agree on anything but
the words. so :
mircea_popescu: jurov you don't reorder
them physically. you just keep
the ring's index up
to date.
jurov: re: ring buffer - does not solve
the fragmentation
the moment you want
to reorder
txs by fee. i see it as either using slab allocator or periodically dumping whole mempool
to disk and reread it
mircea_popescu: ascii_field you misunderstand
the "play with pebbles". it's doing stuff like playing angry birds on iphone.
☟︎ jurov: ascii_field: so you say
there's math-manhattan-project hidden somewhere?
mircea_popescu: socialism is
this great system
to
take hot chicks and smart boys and make
them all play with pebbles until
the day
they die.
ascii_field: because - elementarily -
there is no place anywhere else for maths
types
ascii_field: i suspect
that usg's internal crypto works
mircea_popescu: from my admittedly limited experience with socialist states...
they all eat
the same shit.
ascii_field: i have not seen
the internal one, save
the supposedly 'leaked' pages, cannot say what it is like.
mircea_popescu: to quote
the richest standup comedian of all
time, "wouldn't it stand
to reason
that
the air in your room comes from
the very city
that room is in ?"
ascii_field: i can absolutely believe
that 'cryptol' is used in hitler's phone etc
mircea_popescu: i mean haskell, i get it. pseudomathematicisms
that are
too gnarly
to grasp and so pass muster.
mircea_popescu: "If
the space of possible messages is larger
than
the size of ,
then Cramer–Shoup may be used in a hybrid cryptosystem
to improve efficiency on long messages. Note
that it is not possible
to split
the message into several pieces and encrypt each piece independently, because
the chosen-ciphertext security property is not preserved in
this way."
ascii_field: sorta lulzy, it was inevitable for
them
to end up with just
this, because
they hire academics
ascii_field: not even a bad idea, it's
this vaguely standardml-like contraption where you
try
to prove
that your crypto alg works as specced
ascii_field: it is made by galois inc.,
they call it 'cryptol'
mircea_popescu: anyway, none of
this is even practical without mass cardanos, because iirc c-s consumes even more entropy
than rsa.
ascii_field: well if mircea_popescu can locate another me but one
that doesn't work a day job, he can ask for one
mircea_popescu: seems like
the dream application for lisp, but what do i know.
ascii_field: ('slow' is a curable
thing, generally; 'bloated' is not)
mircea_popescu: also has
the bonus advantage
that
there's exactly no risk of "clever" processor intructions being used.
ascii_field: incidentally, i am not satisfied with any of
the proposed replacements for pkcs
ascii_field: normally, acca relies on sidechannels (e.g., karatsuba mult.
timing)
mircea_popescu: maybe.
the matter has
to be properly analyzed for all other schemes
ascii_field: if
time invariants are held
to,
this reduces
to key bruteforcing
ascii_field: because
the channel is saturated at all
times.
ascii_field: only if
the relayed packet
travels plaintext
mircea_popescu: node m connects
to A, sends garbage. if A manages
to decrypt it, M will see it.
mircea_popescu: suppose you build a node. your node "doesn't answer", but it DOES publish
the relayed
txn somewhere.
ascii_field: which - yes - means
that
time quanta are fixed
ascii_field: enemy has no way of learning anything from
the attempted decrypt
mircea_popescu: ascii_field your gossipd node is stuck doing a version of
this.
ascii_field: when folks start
to attempt decryption of whatever piece of shit, just for
the asking -
then yes, acca
☟︎