old-new-win32api
Folly
old-new-win32api | Folly | |
---|---|---|
34 | 90 | |
237 | 27,072 | |
- | 0.5% | |
4.7 | 9.8 | |
2 months ago | 7 days ago | |
C++ | ||
- | Apache License 2.0 |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
old-new-win32api
-
Why does part of the Windows 98 Setup program look older than the rest?
Do you have any recommendations?
I assume this is the one you’re talking about https://devblogs.microsoft.com/oldnewthing/
I was curious, went to the end (page 699!) and it’s pretty interesting. But obviously it’s hard to find the important ones.
- Frontman of Weezer, Rivers Cuomo, is an active developer on GitHub
-
Windows NT: Peeking into the Cradle
Not quite. DOS was just the bootloader for Windows 9x.
While Windows 95's kernel didn't have the full feature set of NT, it still was more sophisticated than DOS.
Source: https://devblogs.microsoft.com/oldnewthing/?p=24063
-
KSP2 is spamming the Windows Registry until the game stops working permanently
Some registry keys also have The Old New Thing posts by Raymond Chen [1] /s
[1] https://github.com/mity/old-new-win32api#registry
-
Lookin for a decent C++ data structure resource
Lucky you, Raymond Chen did an overview in his blog series "Inside STL". You can view it here: https://devblogs.microsoft.com/oldnewthing/
-
Microsoft's backwards compatibility is insane
Yes, Raymond Chen describes such fixes in [several blog posts](https://devblogs.microsoft.com/oldnewthing/) and in his book The Old New Thing. Check the old posts, back at the beginning. There are posts about to which lengths they went to ensure buggy applications still worked after an update or a fix.
-
Is there a known reason that Vista's startup screen was so plain?
https://learn.microsoft.com/en-us/archive/blogs/larryosterman/ https://learn.microsoft.com/en-us/archive/blogs/ https://devblogs.microsoft.com/oldnewthing/
-
Technical articles recommendation
A couple of blogs as an example: - Raymond Chen - https://devblogs.microsoft.com/oldnewthing/ - Pavel Yosifovich - https://scorpiosoftware.net/ - Adam Sawicki - https://asawicki.info/index - Matt Pettineo - https://therealmjp.github.io/ - Scratchapixel - https://www.scratchapixel.com/
-
Ask HN: Who are tech bloggers with a good archive?
https://devblogs.microsoft.com/oldnewthing/
- Why is the FAT directory creation time 24 bits and not 16 bits like the modified time?
Folly
-
Ask HN: How bad is the xz hack?
https://github.com/facebook/folly/commit/b1391e1c57be71c1e2a...
-
Backdoor in upstream xz/liblzma leading to SSH server compromise
https://github.com/facebook/folly/pull/2153
-
A lock-free ring-buffer with contiguous reservations (2019)
To set a HP on Linux, Folly just does a relaxed load of the src pointer, release store of the HP, compiler-only barrier, and acquire load. (This prevents the compiler from reordering the 2nd load before the store, right? But to my understanding does not prevent a hypothetical CPU reordering of the 2nd load before the store, which seems potentially problematic!)
Then on the GC/reclaim side of things, after protected object pointers are stored, it does a more expensive barrier[0] before acquire-loading the HPs.
I'll admit, I am not confident I understand why this works. I mean, even on x86, loads can be reordered before earlier program-order stores. So it seems like the 2nd check on the protection side could be ineffective. (The non-Linux portable version just uses an atomic_thread_fence SeqCst on both sides, which seems more obviously correct.) And if they don't need the 2nd load on Linux, I'm unclear on why they do it.
[0]: https://github.com/facebook/folly/blob/main/folly/synchroniz...
(This uses either mprotect to force a TLB flush in process-relevant CPUs, or the newer Linux membarrier syscall if available.)
-
Appending to an std:string character-by-character: how does the capacity grow?
folly provides functions to resize std::string & std::vector without initialization [0].
[0] https://github.com/facebook/folly/blob/3c8829785e3ce86cb821c...
-
Can anyone explain feedback of a HFT firm regarding implementation of SPSC lock-free ring-buffer queue?
My implementation was quite similar to Boost's spsc_queue and Facebook's folly/ProducerConsumerQueue.h.
-
A Compressed Indexable Bitset
> How is that relevant?
Roaring bitmaps and similar data structures get their speed from decoding together consecutive groups of elements, so if you do sequential decoding or decode a large fraction of the list you get excellent performance.
EF instead excels at random skipping, so if you visit a small fraction of the list you generally get better performance. This is why it works so well for inverted indexes, as generally the queries are very selective (otherwise why do you need an index?) and if you have good intersection algorithms you can skip a large fraction of documents.
I didn't follow the rest of your comment, select is what EF is good at, every other data structure needs a lot more scanning once you land on the right chunk. With BMI2 you can also use the PDEP instruction to accelerate the final select on a 64-bit block: https://github.com/facebook/folly/blob/main/folly/experiment...
-
Defer for Shell
C++ with folly's SCOPE_EXIT {} construct:
https://github.com/facebook/folly/blob/main/folly/ScopeGuard...
-
Is there any facebook/folly community for discussion and Q&A?
Seems like github issues taking a long time to get any response: https://github.com/facebook/folly
-
How a Single Line of Code Made a 24-Core Server Slower Than a Laptop
Can't speak for abseil and tbb, but in folly there are a few solutions for the common problem of sharing state between a writer that updates it very infrequently and concurrent readers that read it very frequently (typical use case is configs).
The most performant solutions are RCU (https://github.com/facebook/folly/blob/main/folly/synchroniz...) and hazard pointers (https://github.com/facebook/folly/blob/main/folly/synchroniz...), but they're not quite as easy to use as a shared_ptr [1].
Then there is simil-shared_ptr implemented with thread-local counters (https://github.com/facebook/folly/blob/main/folly/experiment...).
If you absolutely need a std::shared_ptr (which can be the case if you're working with pre-existing interfaces) there is CoreCachedSharedPtr (https://github.com/facebook/folly/blob/main/folly/concurrenc...), which uses an aliasing trick to transparently maintain per-core reference counts, and scales linearly, but it works only when acquiring the shared_ptr, any subsequent copies of that would still cause contention if passed around in threads.
[1] Google has a proposal to make a smart pointer based on RCU/hazptr, but I'm not a fan of it because generally RCU/hazptr guards need to be released in the same thread that acquired them, and hiding them in a freely movable object looks like a recipe for disaster to me, especially if paired with coroutines https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p05...
-
Ask HN: What are some of the most elegant codebases in your favorite language?
Not sure if it's still the case but about 6 years ago Facebook's folly C++ library was something I'd point to for my junior engineers to get a sense of "good" C++ https://github.com/facebook/folly
What are some alternatives?
winforms - Windows Forms is a .NET UI framework for building Windows desktop applications.
abseil-cpp - Abseil Common Libraries (C++)
anbox - Anbox is a container-based approach to boot a full Android system on a regular GNU/Linux system
Boost - Super-project for modularized Boost
reactos - A free Windows-compatible Operating System
Seastar - High performance server-side application framework
GameStretcher - Run 2D Windows Games (GDI, DirectDraw, D3D9) with a stretchable window, and a SuperXBR upscale filter
parallel-hashmap - A family of header-only, very fast and memory-friendly hashmap and btree containers.
AnyAny - C++17 library for comfortable and efficient dynamic polymorphism
EASTL - Obsolete repo, please go to: https://github.com/electronicarts/EASTL
apps - a monorepo of all my python scripts, modules, and packages
OpenFrameworks - openFrameworks is a community-developed cross platform toolkit for creative coding in C++.