FluidX3D
xv6-public
FluidX3D | xv6-public | |
---|---|---|
53 | 25 | |
3,227 | 7,408 | |
- | 1.3% | |
8.6 | 0.0 | |
4 days ago | 4 days ago | |
C++ | C | |
GNU General Public License v3.0 or later | GNU General Public License v3.0 or later |
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.
FluidX3D
- FluidX3D
-
Earthquake in Japan yesterday may have shifted land 1.3 meters
Could even use this as a revers GLOBAL ORBITING SYSTEM [GoS] - Whereby a single satellite|probe dispels a lander to a planet with the Quantum Magnetic Cannister, and that QMC signals its global location to the satellite launcher, and the satellit can extrap its location based on the absolute location of the ground guys... (might need more than one ground magnet-moles?)
How can this be measured? Can fluidx3d do martian magnetics? [0]
--
[0] https://github.com/ProjectPhysX/FluidX3D
---
EDIT: "Mars does not have a magnetosphere"
ELI5: "how do electronics work when there is zero magnetic field around them? A complete antimagnetic environ?"
I've never heard any mention about making any electrical device work on a planet (such as mars) in a complete magnetically dark location?
How is there gravity on mars if there is no magnetic field for a planet, and how can mass, the size of a planet not produce magnetism/gravity if its not made of iron-sh (the RED of the planet)
ELI5, please.
-
Challenging projects every programmer should try
See my post in this thread about dimples/barnacles...
But have you seen this guys package: https://github.com/ProjectPhysX/FluidX3D
- Fast and Memory efficient lattice Boltzmann CFD software, running on all GPUs
-
What 8x AMD Instinct MI200 GPUs can do with a combined 512GB VRAM: Bell 222 Helicopter in FluidX3D CFD - 10 Billion Cells, 75k Time Steps, 71TB vizualized - 6.4 hours compute+rendering with OpenCL
Yes, I've made that super easy. You can change the VRAM capacity of your hardware as one number in the setup script and it will automatically scale the simulation up or down. See the documentation for details.
-
Need help : I' using FluidX3D, and this model is taken from the game Assetto Corsa (.kn5 file) and converted in stl using blender. In blender and many stl file viewer it shows fine but when I try to use FluidX3D it shows weird lines and I don't know why. I tried using other methods to convert t
Also see this GitHub Issue on the problem: https://github.com/ProjectPhysX/FluidX3D/issues/59
-
Real time CFD with FluidX3D - Cessna 172 - 20 million cells - Titan Xp GPU
If you want to play with the software yourself, FluidX3D is on GitHub: https://github.com/ProjectPhysX/FluidX3D
-
GPUs in CFD
This is my opinion about what is happening. Production CFD solvers are really complicated and take a lot of time and energy to write. Engineers learning to use a CFD solver to get a job done is really time consuming and there are all sorts of issue that come up like actually trusting the new solver. Both of these things have really held back GPUs in this area. There are really only two ways out of this, either you write a solver from scratch and get people to adopt it (double hard) or you take an existing solver and modify it to run on GPUs (still pretty hard). The first option is very hard but ultimately the way to go in my opinion. The second option results in very poorly optimized GPU code and honestly just gives a bad name to GPU computing in my opinion. Take OpenLB for example, https://www.openlb.net/show-cases/highly-resolved-nozzle-simulation-performed-using-multi-gpu-support/. Terrible terrible performance compared to what you could get if you wrote the solver from scratch on the GPU, for example, https://github.com/ProjectPhysX/FluidX3D.
- Where to try/test (and learn) CFD models for free?
- FluidX3D: Fast, memory efficient lattice Boltzmann CFD software /w OpenCL
xv6-public
-
Challenging projects every programmer should try
+1 for mini operating system.
Us, application developers, rely on many OS features: memory management, filesystem, etc. I'm sure eventually we'll ask "how such things are done behind the scene?"
That's why I tinker with xv6 (https://github.com/mit-pdos/xv6-public) during sparetime. Learning various process scheduling algorithms from textbook is a thing. Implementing it is another thing. I learn a lot. And it's definitely fun, even though there's almost zero chance the knowledge gained is relevant for my job (I'm a mobile app dev).
-
xv6 compile error
Recently I compiled xv6 using gcc 7.5.0 on Ubuntu 18 , everything is ok. But when I try to compile it using gcc 13.2.1 on latest Arch, it's failed: result
-
How could the early Unix OS comprise so few lines of code?
https://github.com/mit-pdos/xv6-public has under 10,000 lines of C and assembly including some user space programs.
-
The rxv64 Operating System: MIT's xv6, in Rust, for SMP x86_64 machines
xv6 was originally written for 32-bit x86; the RISC-V port is a relatively recent development. See e.g. https://github.com/mit-pdos/xv6-public for some of the earlier history.
rxv64 was written for a specific purpose: we had to ramp up professional engineers on both 64-bit x86_64 and kernel development in Rust; we were pointing them to the MIT materials, which at the time still focused on x86, but they were getting tripped up 32-bit-isms and the original PC peripherals (e.g., accessing the IDE disk via programmed IO). Interestingly, the non sequitur about C++ aside, porting to Rust exposed several bugs or omissions in the C original; fixes were contributed back to MIT and applied to the original (and survived into the RISC-V port).
Oh, by the way, the use of the term "SMP" predates Intel's usage by decades.
-
Some were meant for C [pdf]
I'd define an arena as the pattern where the arena itself owns N objects. So you free the arena to free all objects.
My first job was at EA working on console games (PS2, GameCube, XBox, no OS or virtual memory on any of them), and while at the time I was too junior to touch the memory allocators themselves, we were definitely not malloc-ing and freeing all the time.
It was more like you load data for the level in one stage, which creates a ton of data structures, and then you enter a loop to draw every frame quickly. There were many global variables.
---
Wikipedia calls it a region, zone, arena, area, or memory context, and that seems about right:
https://en.wikipedia.org/wiki/Region-based_memory_management
It describes history from 1967 (before C was invented!) and has some good examples from Apache ("pools") and Postgres ("memory contexts").
I also just looked at these codebases:
https://github.com/mit-pdos/xv6-public (based on code from the 70's)
https://github.com/id-Software/DOOM (1997)
I looked at allocproc() in xv6, and gives you an object from a fixed global array. A lot of C code in the 80's and 90's was essentially "kernel code" in that it didn't have an OS underneath it. Embedded systems didn't run on full-fledges OSes.
DOOM tends to use a lot of what I would call "pools" -- arrays of objects of a fixed size, and that's basically what I remember from EA.
Though in g_game.c, there is definitely an arena of size 0x20000 called "demobuffer". It's used with a bump allocator.
---
So I'd say
- malloc / free of individual objects was NEVER what C code looked like (aside from toy code in college)
- arena allocators were used, but global vars and pools are also very common.
- arenas are more or less wash for memory safety. they help you in some ways, but hurt you in others.
The reason C programmers don't malloc/free all the time is for speed, not memory safety. Arenas are still unsafe.
When you free an arena, you have no guarantee there's nothing that points to it anymore.
Also, something that shouldn't be underestimated is that arena allocators break tools like ASAN, which use the malloc() free() interface. This was underscored to me by writing a garbage collector -- the custom allocator "broke" ASAN, and that was actually a problem:
https://www.oilshell.org/blog/2023/01/garbage-collector.html
If you want memory safety in your C code, you should be using ASAN (dynamically instrumented allocators) and good test coverage. Arenas don't help -- they can actually hurt. An arena is a trivial idea -- the problem is more if that usage pattern actually matches your application, and apps evolve over time.
- Run Linux Programs on DOS
-
The Magma operating system
Magma is proudly licensed under the MIT license, and uses code from Xv6 and Yagura.
-
User Space vs Kernel Space Development (For an experienced Dev)
My OS classes used xv6, a reimplementation of Unix Version 6 for a RISC-V architecture. Accompanying that was the OSTEP textbook.
-
MINIX is an awesome way to learn a wide range of CS concepts
Check out xv6 if you are only getting started with operating systems and want something simpler.
-
I am getting an undefined reference despite including the source file when compiling
Here is kernel.ld.
What are some alternatives?
HPX - The C++ Standard Library for Parallelism and Concurrency
xv6-riscv - Xv6 for RISC-V
OpenCL-examples - Simple OpenCL examples for exploiting GPU computing
homebrew-i386-elf-toolchain - Homebrew formulas for buildling a valid GCC toolchain for the i386-elf target.
McCode - The home of the McStas (neutrons) and McXtrace (x-rays) Monte-Carlo ray-tracing instrument simulation codes.
minixfromscratch - Development and compilation setup for the book versions of MINIX (2.0.0 and 3.1.0) on QEMU
pysph - A framework for Smoothed Particle Hydrodynamics in Python
foam3 - FOAM: Feature-Oriented Active Modeller, Version 3 (unstable)
lbm - A simple full-python 2D lattice-boltzmann code
stumpwm - The Stump Window Manager
intel-extension-for-tensorflow - Intel® Extension for TensorFlow*
lispe - An implementation of a full fledged Lisp interpreter with Data Structure, Pattern Programming and High level Functions with Lazy Evaluation à la Haskell.