retro | nullCreate session for your team | Frontend Framework library

Your first stops for further reading should probably be:

• What Every Programmer Should Know About Memory? re: cache
• https://agner.org/optimize/ re: everything else about writing efficient asm.
• https://uops.info/ for a better version of Agner Fog's instruction tables.
• See also other links in https://stackoverflow.com/tags/x86/info

so I will put out microoptimalisation until it will suffer performance problems and then I will start with profiling.

Yes, probably good to start trying stuff so you have something to profile with HW performance counters, so you can correlate what you're reading about performance stuff with what actually happens. And so you get some ideas of possible details you hadn't thought of yet before you go too far into optimizing your overall design idea. You can learn a lot about asm micro-optimization by starting with something very small scale, like a single loop somewhere without any complicated branching.

Since modern CPUs use split L1i and L1d caches and first-level TLBs, it's not a good idea to place code and data next to each other. (Especially not read-write data; self-modifying code is handled by flushing the whole pipeline on any store too near any code that's in-flight anywhere in the pipeline.)

Related: Why do Compilers put data inside .text(code) section of the PE and ELF files and how does the CPU distinguish between data and code? - they don't, only obfuscated x86 programs do that. (ARM code does sometimes mix code/data because PC-relative loads have limited range on ARM.)

Yes, making sure all your data allocations are nearby should be good for TLB locality. Hardware normally uses a pseudo-LRU allocation/eviction algorithm which generally does a good job at keeping hot data in cache, and it's generally not worth trying to manually clflushopt anything to help it. Software prefetch is also rarely useful, especially in linear traversal of arrays. It can sometimes be worth it if you know where you'll want to access quite a few instructions later, but the CPU couldn't predict that easily.

AMD's L3 cache may use adaptive replacement like Intel does, to try to keep more lines that get reused, not letting them get evicted as easily by lines that tend not to get reused. But Zen2's 512kiB L2 is relatively big by Forth standards; you probably won't have a significant amount of L2 cache misses. (And out-of-order exec can do a lot to hide L1 miss / L2 hit. And even hide some of the latency of an L3 hit.) Contemporary Intel CPUs typically use 256k L2 caches; if you're cache-blocking for generic modern x86, 128kiB is a good choice of block size to assume you can write and then loop over again while getting L2 hits.

The L1i and L1d caches (32k each), and even uop cache (up to 4096 uops, about 1 or 2 per instruction), on a modern x86 like Zen2 (https://en.wikichip.org/wiki/amd/microarchitectures/zen_2#Architecture) or Skylake, are pretty large compared to a Forth implementation; probably everything will hit in L1 cache most of the time, and certainly L2. Yes, code locality is generally good, but with more L2 cache than the whole memory of a typical 6502, you really don't have much to worry about :P

Of more concern for an interpreter is branch prediction, but fortunately Zen2 (and Intel since Haswell) have TAGE predictors that do well at learning patterns of indirect branches even with one "grand central dispatch" branch: Branch Prediction and the Performance of Interpreters - Don’t Trust Folklore

Connect to your database 1st and after that start your server.

You're trying to query the database without connecting to your database.

https://mongoosejs.com/docs/connections.html#buffering

Mongoose lets you start using your models immediately, without waiting for mongoose to establish a connection to MongoDB.

That's because mongoose buffers model function calls internally. This buffering is convenient, but also a common source of confusion. Mongoose will not throw any errors by default if you use a model without connecting.

Where does the initial state that you want to compress come from? I guess there are three likely options.

1. It's random. Most likely that means some code seeded a pseudo random number generator using some value like e.g. the time of the day, then used that to produce the values. In this case, you could get your hands on the seed (which most likely would be a fairly short number) and use that as the identifier from which everything else is computed. Make sure to use a portable random number generator with well-defined deterministic behaviour, e.g. some Mersenne Twister implementation. The JavaScript built in number generator is implementation-defined so it does not fit this bill.

2. It came from some catalog made by the game developer (i.e. you). Then just obfuscating the index into that catalog might be good enough.

3. It came from some user hand-tuning the values. In this case you're out of luck, since as I understand the problem chances are that any possible combination could get entered. You can't compress a large set of values to a smaller set of values without losing information.

There might be middle grounds. You could have a randomised setup that subsequently got hand-tuned, and the description as initial seed plus a few modifications would be shorter than the full set of settings. Or the hand-tuning would only be allowed following specific rules set out by the game developer, which again would make for a limited set of possible values and a potentially shorter encoding. Thinking along these categories might help you analyze your own situation and find a suitable solution.

You can also look at this from an information theory point of view. You can't expect to encode a sequence of fully independent and uniformly distributed digits with less information than those digits, perhaps expressed in some other base or whatever. You can compress data if there are patterns to it that make some combinations more likely than others. The more you tell us about these patterns, the better we might be able to advise. In total you can't get below the entropy of the source (i.e. game state distribution), so estimating that might help you find a lower bound for what to expect.

You should use a different css locator. Also, you should find parent elements and put them to the list.

After that - iterate through the list and get href attribute value.

I have given just the approach this code will work in your case. But this code can be optimized way better. I hope you can do it on your own.

Something like this?

You didn't identify "Users" so you can chick as:

Your question doesn't make a lot of sense, because it's imposing bizarre restrictions that we can't really assess, but I don't mind telling you how to join two joins

You already know how to join three tables in the normal/traditional/sensible sense. Here's how to join them as you ask:

As a rule, turtles can never appear behind anything drawn by turtles. I recommend you put up your "loading" screen message, and create your turtles invisibly: