Suggest me some good ones that I can do in C or Rust. Distributed systems, operating systems domain.

Suggest me some good ones that I can do in C or Rust. Distributed systems, operating systems domain.

Let's look back at some memorable moments and interesting insights from last year.

Your top 10 posts:

• "NASA says Category Theory is the “Mathematical Basis of Systems Engineering.”" by u/AissySantos
• "Low-Latency, High-Throughput Garbage Collection" by u/sanxiyn
• "Lock-Free Locks Revisited [2022]" by u/h2o2
• "RDMA is Turing complete, we just did not know it yet! [2021]" by u/h2o2
• "What makes a ‘really good’ systems programmer" by u/bengtsson123
• "ghOSt: Fast & Flexible User-Space Delegation of Linux Scheduling" by u/sanxiyn
• "Safety and Liveness Properties" by u/mttd
• "nsync: a C library that exports various synchronization primitives" by u/sanxiyn
• "DAOS: Data access-aware operating system [2022]" by u/h2o2
• "Simple Simulations for System Builders" by u/mttd

Probably a dumb question, but having never taken any compiler/OS course, I couldnt find any answer online. Say, I have a program, which calls a shared library API , and that needs a pointer to be passed, which the library will fill with data. So, in my func_a(), if I create a local variable, pass the address of this to the library, when the library tries to fill that pointer, how will it work? Because my basic OS knowledge was that, each program has its own virtual addr space, so passing my local variable' addr to that lib, and if the lib tries to dereference, how does addr translation work? Wouldnt the lib have its own virtual addr space and could conflict my local addr space?

void func_a()

{

struct local lcl;

get_lcl_filled(&lcl);

}

​

----- library;

void get_lcl_filled( struct local * p_lcl)

{

struct local temp;

strcpy(temp.name, "ABC");

p_lcl->id = 123;

strcpy(p_lcl->name, temp.name);

return;

}

Everything I know about (TCP) congestion control in data center is quite old, having covered the basics in an undergraduate computer networking class. I also realize the state of the art has moved along quite a lot -- modern networks have multiple links, different topologies and load balance across them, ECN is more common place and algorithms based on BW-delay product, explicit admission control and RTT measurements are commonplace. Finally, I also realize that there are schemes and approaches that I probably don't even know of given I haven't followed this field closely.

There seems to be a complex play between workloads, desired properties, network topologies and algorithms and I'm looking for anything a primer/summary/lecture notes/class on the underlying principles and concepts on which modern algorithms are being designed. Anything that would allow a person 20 years out-of-date to come up to speed in the developments that have happened in the last 20 years.

As a bonus I would also appreciate any links to papers/resources on how modern data center topologies are constructed and used (if any exist).

I realise there may not be a "one resource" but a series of papers; for those that follow this field, what would you recommend?

So I recently got interested in systems programming and I like it. I have been learning Go and Rust. I know to expand the potential projects I can do, it would useful to learn operating systems, distributed systems, compilers and probably take a computer systems class. Throughout the process I’d hopefully find what I like and dig deeper.

However, I don’t have an idea of what makes a decent systems programmer. I believe that it would be a good thing to have a sense of an ideal I can work towards. It doesn’t have to be objective. I think one would be useful to make me plan for my study and progress. Currently I just have project ideas which idk if it’s all I should do.

Maybe I have a skewed sense of what I should do in this space. I would appreciate any direction.

I studied that in Linux, user level threads are mapped 1:1 to kernel level threads, and threads have the same type of PCB that we are for processes. About Windows, what's the difference with Linux? I studied that Windows threads are mapped m:n with pools of worker threads. So:

• Are the created threads just shown in the system process table (the table that contains all the pid and the pointers to the relative PCB in memory) like all the processes, or they aren't? If not, where are they stored? How can the scheduler decide if they are not in the system process table?
• Since when I start a simple process, it is itself a thread (I can check it via ps command, and on Windows it should be the same), what's the difference between them? Is there a difference on how the system (Linux or Windows) see them? Or are they the same thing but the the "non-main" threads(the ones created within the process) share the same virtual address space with the main-thread(the process that created them)?
• How are threads told to access only certain things, if they have the same "block map table" in the PCB since they have the same virtual address space (and thus could in theory access everything)? Who sets and sees the constraints? Where are these constraints written?
• Does pthread library simply provides API that will create a kernel level thread starting from a user level thread(so 1:1 mapping), setting the relative priority(I can do it via pthread, but I don't know how this scheduling priority is handled) of the kernel level thread that will be seen by the kernel in scheduling act? Or maybe EVERY time the kernel level thread corresponding to one of my user level threads is scheduled, pthread MUST act as middleman and then there is this forced "bridge" and this overhead maybe because pthread library can manage scheduling things (again like I said before, when I start a thread with pthread, I can set some scheduling priority in my threads) so maybe it can dynamically choose which of its (pthread's) user level thread to run, when any of the kernel level thread of its (pthread's) is scheduled?

Let's look back at some memorable moments and interesting insights from last year.

Your top 10 posts:

• "Twizzler: a Data-Centric OS for Non-volatile Memory" by u/sanxiyn
• "Intel C/C++ compilers complete adoption of LLVM" by u/lindaarden
• "Chain loading, not preloading: the dynamic linker as a virtualization vector" by u/mttd
• "Reliable Stack Traces, the Reality of Myth: DWARF Stack Unwinding and other stories" by u/mttd
• "USENIX ATC '21/OSDI '21 Joint Keynote Address - It's Time for Operating Systems to Rediscover Hardware" by u/Alaric
• "New blog on systems programming bugs" by u/Notonlycs
• "A Modern Primer on Processing in Memory [2020]" by u/h2o2
• "Happy Cakeday, r/systems! Today you're 11" by u/AutoModerator
• "Asymmetry-aware Scalable Locking [2021]" by u/h2o2
• "Slitter: a slab allocator that trusts, but verifies (in Rust, for C) [HTML, 2021]" by u/sbahra