[Doc] Revise "Why a new programming language" #4306
Merged
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
|
✔️ Deploy Preview for docsite-preview ready! 🔨 Explore the source changes: dde36a4 🔍 Inspect the deploy log: https://app.netlify.com/sites/docsite-preview/deploys/620df3fcf0620500077300a0 😎 Browse the preview: https://deploy-preview-4306--docsite-preview.netlify.app |
k-ye
commented
Feb 16, 2022
|
|
||
| Going forward, we see many new opportunities lying ahead this path, and would like to share some of our vision with you. | ||
|
|
||
| **Academia** |
There was a problem hiding this comment.
Additional input regarding this part :-)? @ltt1598
There was a problem hiding this comment.
I think we can echo the high productivity using Taichi at first: 90% of the research code will be trashed due to the nature of research where assumptions keep being broken and ideas keep being iterated. Swiftly coding without thinking too much about performance may lead to incorrect conclusions, while pre-matured code optimization can be a waste of time and often produces a tangled mess. The high performance and productivity are, therefore, extremely helpful for research projects.
The key features we have (or plan to have) for high-performance computing research projects include small-scale linear algebra (inside kernels), large-scale sparse systems, and efficient neighbor accessing for both structured and unstructured data.
We also provide an automatic differentiation module via source code transformation (at IR level), making Taichi a sweet differentiable simulation tool for machine learning projects.
|
/format |
turbo0628
reviewed
Feb 16, 2022
turbo0628
reviewed
Feb 16, 2022
| * [taichimd](https://github.com/victoriacity/taichimd): Interactive, GPU-accelerated Molecular (& Macroscopic) Dynamics using the Taichi programming language | ||
| * [TaichiSLAM](https://github.com/xuhao1/TaichiSLAM): a 3D Dense mapping backend library of SLAM based Taichi-Lang, designed for the aerial swarm. | ||
| * [Stannum](https://github.com/ifsheldon/stannum): Fusing Taichi into PyTorch. | ||
|
|
There was a problem hiding this comment.
Maybe we can also mention the fluid solver here? https://github.com/hietwll/LBM_Taichi
There was a problem hiding this comment.
I was hoping to use some cases that are not simulation LOL
Co-authored-by: Haidong Lan <turbo0628g@gmail.com>
|
I truly enjoy reading this article, LGTM! |
|
I like the new "why new programming language" page! |
|
Never in my life have I read something its equal. Inspiring, enlightening, and a breath of fresh air! |
|
/format |
|
Three warm compliments without a single LGTM, I'm heartbroken... |
|
LGTM now :) |
|
|
||
| Taichi is a high-performance programming language for computer graphics | ||
| applications. The design goals are | ||
| Imagine you'd like to write a new particle-based fluid algorithm. You started simple, didn't spend much time before finding a reference C++/CUDA work online (or derived the work from your labmate, <s>un</s>fortunately). `cmake .. && make`, you typed. Oops, cmake threw out an error due to a random incompatible third party library. Installed and rebuilt, now it passed. Then you ran it, which immediately segfaulted (without any stacktrace, of course). Then you started gazing at the code, placed the necessary asset files at the right place, fixed a few dangling pointers and reran. It... actually worked, up until the point where you started plugging in your revised algorithm. Now another big fight with the GPU or CPU code. More often than not, you get lost in the language details. |
There was a problem hiding this comment.
Suggested change
| Imagine you'd like to write a new particle-based fluid algorithm. You started simple, didn't spend much time before finding a reference C++/CUDA work online (or derived the work from your labmate, <s>un</s>fortunately). `cmake .. && make`, you typed. Oops, cmake threw out an error due to a random incompatible third party library. Installed and rebuilt, now it passed. Then you ran it, which immediately segfaulted (without any stacktrace, of course). Then you started gazing at the code, placed the necessary asset files at the right place, fixed a few dangling pointers and reran. It... actually worked, up until the point where you started plugging in your revised algorithm. Now another big fight with the GPU or CPU code. More often than not, you get lost in the language details. | |
| Imagine you'd like to write a new particle-based fluid algorithm. You started simple, didn't spend much time before finding a reference C++/CUDA work online (or derived the work from your labmate, <s>un</s>fortunately). `cmake .. && make`, you typed. Oops, cmake threw out an error due to a random incompatible third party library. Installed and rebuilt, now it passed. Then you ran it, which immediately segfaulted (without any stacktrace, of course). Then you started gazing at the code, placed the necessary asset files at the right place, fixed a few dangling pointers and reran. It... actually worked, until you plugged in your revised algorithm. Now another big fight with the GPU or CPU code. More often than not, you get lost in the language details. |
to the point where: refers to a place, or a situation
to the point when: refers to a point in time
|
|
||
| ## Design decisions | ||
| Originally born from the MIT CSAIL lab, Taichi was designed to facilitate computer graphics researchers' day-to-day life, by helping them quickly implement visual computing and physics simulation algorithms that are executable on GPU. The path Taichi took was an innovative one: Taichi is embedded in Python, and utilizes the modern just-in-time (JIT) frameworks (e.g., LLVM, SPIR-V) to offload the Python source code to native GPU or CPU instructions, offering the performance at both development time and runtime. |
There was a problem hiding this comment.
Suggested change
| Originally born from the MIT CSAIL lab, Taichi was designed to facilitate computer graphics researchers' day-to-day life, by helping them quickly implement visual computing and physics simulation algorithms that are executable on GPU. The path Taichi took was an innovative one: Taichi is embedded in Python, and utilizes the modern just-in-time (JIT) frameworks (e.g., LLVM, SPIR-V) to offload the Python source code to native GPU or CPU instructions, offering the performance at both development time and runtime. | |
| Born from the MIT CSAIL lab, Taichi was designed to facilitate computer graphics researchers' everyday life, by helping them quickly implement visual computing and physics simulation algorithms that are executable on the GPU. Taichi is embedded in Python and uses the modern just-in-time (JIT) frameworks (for example LLVM, SPIR-V) to offload the Python source code to the native GPU or CPU instructions. This innovative approach accelerates development and reduces runtime. |
There was a problem hiding this comment.
Thanks! I fixed some, but prefer to keep "The path Taichi took was an innovative one..."
| - Embedding in Python | ||
| To be fair, a domain-specific language (DSL) with a Python frontend is not something new. In the past few years, frameworks like Halide, PyTorch and TVM have grown ripe and become the de facto standards in areas like image processing and deep learning (DL). What differentiates Taichi the most from these frameworks is its imperative programming paradigm. Being a DSL, Taichi isn't so specialized in a particular computing pattern, thus provides better flexibility. While one may argue that flexibility usually comes at a cost of not being fully optimized, we find this is often not the case for a few reasons. | ||
|
|
||
| 1. Taichi's workload typically does *not* exhibit an exploitable pattern (e.g., element-wise operations), meaning that the arithmetic intensity is bounded anyway. By simply switching to the GPU backend, one can already enjoy a nice performance gain. |
There was a problem hiding this comment.
Suggested change
| 1. Taichi's workload typically does *not* exhibit an exploitable pattern (e.g., element-wise operations), meaning that the arithmetic intensity is bounded anyway. By simply switching to the GPU backend, one can already enjoy a nice performance gain. | |
| - Taichi's workload typically does *not* exhibit an exploitable pattern (e.g., element-wise operations), meaning that the arithmetic intensity is bounded anyway. By simply switching to the GPU backend, one can already enjoy a nice performance gain. |
There was a problem hiding this comment.
Only use numbered bullets for steps.
|
|
||
| **Maybe a new frontend?** | ||
|
|
||
| The benefit of adopting the compiler approach is to decouple the frontend from the backend. Taichi is embedded Python, but who says it needs to stay that way? Stay tuned :-) |
There was a problem hiding this comment.
Suggested change
| The benefit of adopting the compiler approach is to decouple the frontend from the backend. Taichi is embedded Python, but who says it needs to stay that way? Stay tuned :-) | |
| The benefit of adopting the compiler approach is that you can decouple the frontend from the backend. Taichi is *currently* embedded in Python, but who says it needs to stay that way? Stay tuned :-) |
| - Megakernels | ||
| - Two-scale automatic differentiation | ||
| - Embedding in Python | ||
| To be fair, a domain-specific language (DSL) with a Python frontend is not something new. In the past few years, frameworks like Halide, PyTorch and TVM have grown ripe and become the de facto standards in areas like image processing and deep learning (DL). What differentiates Taichi the most from these frameworks is its imperative programming paradigm. Being a DSL, Taichi isn't so specialized in a particular computing pattern, thus provides better flexibility. While one may argue that flexibility usually comes at a cost of not being fully optimized, we find this is often not the case for a few reasons. |
There was a problem hiding this comment.
Suggested change
| To be fair, a domain-specific language (DSL) with a Python frontend is not something new. In the past few years, frameworks like Halide, PyTorch and TVM have grown ripe and become the de facto standards in areas like image processing and deep learning (DL). What differentiates Taichi the most from these frameworks is its imperative programming paradigm. Being a DSL, Taichi isn't so specialized in a particular computing pattern, thus provides better flexibility. While one may argue that flexibility usually comes at a cost of not being fully optimized, we find this is often not the case for a few reasons. | |
| To be fair, a domain-specific language (DSL) with a Python frontend is not something new. In the past few years, frameworks like Halide, PyTorch, and TVM have matured into the de facto standards in areas such as image processing and deep learning (DL). What distinguishes Taichi from these frameworks is its imperative programming paradigm. As a DSL, Taichi is not so specialized in a particular computing pattern. This provides better flexibility. While one may argue that flexibility usually comes at a cost of not being fully optimized, we often find this not the case for the following reasons: |
- "de facto standards". WOW!
- differentiate xxx the most = distinguish
- isn't -> is not. Avoid using contraction.
- come at a cost: fine; come at the cost of xxx.
- You can use "this" to refer to the whole preceding sentence.
There was a problem hiding this comment.
Thx!
nit: I believe it should be "we often find this not to be the case"?
There was a problem hiding this comment.
Personally, I prefer "I find this interesting" to "I find this to be interesting". Same for "I find this not the case".
One usage: "A closer read of the manuscript would find this not the case. "
"This is not the case" is grammatical; "This is not to be the case" is not.
| 3. Taichi heavily optimizes the source code using various compiler technologies: common subexpression elimination, dead code elimination, control flow graph analysis, etc. These optimizations are backend neutral, because Taichi hosts its own intermediate representation layer. | ||
| 4. JIT compilation provides additional optimization opportunities. | ||
|
|
||
| That said, Taichi is much more than just a Python JIT transpiler. One of the initial design goals is to *decouple the computation from the data structures*. The mechanism Taichi provides is a set of generic data containers, called *SNode* (/ˈsnoʊd/). SNodes can be used to compose hierarchical, dense or sparse, multi-dimensional fields conveniently. Switching between array-of-structures and structure-of-arrays layouts is usually a matter of ≤10 lines of code. This has truly enabled many use cases in numerical simulation. If you are interested to learn them, please check out [Fields (advanced)](https://docs.taichi.graphics/lang/articles/advanced/layout), [Sparse spatial data structures](https://docs.taichi.graphics/lang/articles/advanced/sparse), or [the original Taichi paper](https://yuanming.taichi.graphics/publication/2019-taichi/taichi-lang.pdf). |
There was a problem hiding this comment.
Suggested change
| That said, Taichi is much more than just a Python JIT transpiler. One of the initial design goals is to *decouple the computation from the data structures*. The mechanism Taichi provides is a set of generic data containers, called *SNode* (/ˈsnoʊd/). SNodes can be used to compose hierarchical, dense or sparse, multi-dimensional fields conveniently. Switching between array-of-structures and structure-of-arrays layouts is usually a matter of ≤10 lines of code. This has truly enabled many use cases in numerical simulation. If you are interested to learn them, please check out [Fields (advanced)](https://docs.taichi.graphics/lang/articles/advanced/layout), [Sparse spatial data structures](https://docs.taichi.graphics/lang/articles/advanced/sparse), or [the original Taichi paper](https://yuanming.taichi.graphics/publication/2019-taichi/taichi-lang.pdf). | |
| That said, Taichi goes beyond a Python JIT transpiler. One of the initial design goals is to *decouple computation from the data structures*. The mechanism that Taichi provides is a set of generic data containers called *SNode* (/ˈsnoʊd/). SNodes can be used to compose hierarchical, dense or sparse, multi-dimensional fields conveniently. Switching between array-of-structures and structure-of-arrays layouts is usually a matter of ≤10 lines of code. This has sparked many use cases in numerical simulation. If you are interested in learning them, see [Fields (advanced)](https://docs.taichi.graphics/lang/articles/advanced/layout), [Sparse spatial data structures](https://docs.taichi.graphics/lang/articles/advanced/sparse), or [the original Taichi paper](https://yuanming.taichi.graphics/publication/2019-taichi/taichi-lang.pdf). |
- Be interested in doing
There was a problem hiding this comment.
Be interested in doing
Good point, but then I actually searched for that when writing this line...
https://jakubmarian.com/interested-in-doing-vs-interested-to-do-in-english/
There was a problem hiding this comment.
You raised a good point! Go with it!
|
Missing content:
|
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Related issue = #
Preview: https://deploy-preview-4306--docsite-preview.netlify.app/lang/articles/basic/overview