Units
Translation components API.
See the Weblate's Web API documentation for detailed description of the API.
GET /api/translations/documentation/booksarch-handbooksmp_index/fr/units/?format=api
{ "count": 156, "next": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/units/?format=api&page=2", "previous": null, "results": [ { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "SMPng Design Document" ], "previous_source": "", "target": [ "" ], "id_hash": 3396486269137973460, "content_hash": 3396486269137973460, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:1, documentation/content/en/books/arch-handbook/smp/_index.adoc:13", "context": "", "note": "type: Title =", "flags": "no-wrap", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 1, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 3, "source_unit": "https://translate-dev.freebsd.org/api/units/1134164/?format=api", "priority": 100, "id": 1761581, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=af22be443475f0d4", "url": "https://translate-dev.freebsd.org/api/units/1761581/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.686887Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Chapter 8. SMPng Design Document" ], "previous_source": "", "target": [ "" ], "id_hash": -3646889918242395121, "content_hash": -3646889918242395121, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:1", "context": "", "note": "type: YAML Front Matter: title", "flags": "no-wrap", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 2, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 5, "source_unit": "https://translate-dev.freebsd.org/api/units/1134162/?format=api", "priority": 100, "id": 1761582, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=4d63a4f100356c0f", "url": "https://translate-dev.freebsd.org/api/units/1761582/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.687726Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Introduction" ], "previous_source": "", "target": [ "" ], "id_hash": 5330140601372690748, "content_hash": 5330140601372690748, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:51", "context": "", "note": "type: Title ==", "flags": "no-wrap", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 3, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 1, "source_unit": "https://translate-dev.freebsd.org/api/units/1134166/?format=api", "priority": 100, "id": 1761583, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=c9f876a2fbb4c93c", "url": "https://translate-dev.freebsd.org/api/units/1761583/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.688468Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "This document presents the current design and implementation of the SMPng Architecture. First, the basic primitives and tools are introduced. Next, a general architecture for the FreeBSD kernel's synchronization and execution model is laid out. Then, locking strategies for specific subsystems are discussed, documenting the approaches taken to introduce fine-grained synchronization and parallelism for each subsystem. Finally, detailed implementation notes are provided to motivate design choices, and make the reader aware of important implications involving the use of specific primitives." ], "previous_source": "", "target": [ "" ], "id_hash": 3941456065252402286, "content_hash": 3941456065252402286, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:54", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 4, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 80, "source_unit": "https://translate-dev.freebsd.org/api/units/1134168/?format=api", "priority": 100, "id": 1761584, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=b6b2dd689b2da46e", "url": "https://translate-dev.freebsd.org/api/units/1761584/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.689155Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "This document is a work-in-progress, and will be updated to reflect on-going design and implementation activities associated with the SMPng Project. Many sections currently exist only in outline form, but will be fleshed out as work proceeds. Updates or suggestions regarding the document may be directed to the document editors." ], "previous_source": "", "target": [ "" ], "id_hash": -4544286146076902557, "content_hash": -4544286146076902557, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:56", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 5, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 50, "source_unit": "https://translate-dev.freebsd.org/api/units/1134170/?format=api", "priority": 100, "id": 1761585, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=40ef73d3a95b7b63", "url": "https://translate-dev.freebsd.org/api/units/1761585/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.689941Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "The goal of SMPng is to allow concurrency in the kernel. The kernel is basically one rather large and complex program. To make the kernel multi-threaded we use some of the same tools used to make other programs multi-threaded. These include mutexes, shared/exclusive locks, semaphores, and condition variables. For the definitions of these and other SMP-related terms, please see the crossref:smp[smp-glossary, Glossary] section of this article." ], "previous_source": "", "target": [ "" ], "id_hash": -6516304786414838398, "content_hash": -6516304786414838398, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:62", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 6, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 66, "source_unit": "https://translate-dev.freebsd.org/api/units/1724364/?format=api", "priority": 100, "id": 1761586, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=25916f525590dd82", "url": "https://translate-dev.freebsd.org/api/units/1761586/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.690680Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Basic Tools and Locking Fundamentals" ], "previous_source": "", "target": [ "" ], "id_hash": -7789654493086596979, "content_hash": -7789654493086596979, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:64", "context": "", "note": "type: Title ==", "flags": "no-wrap", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 7, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 5, "source_unit": "https://translate-dev.freebsd.org/api/units/1134174/?format=api", "priority": 100, "id": 1761587, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=13e59682888c408d", "url": "https://translate-dev.freebsd.org/api/units/1761587/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.691414Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Atomic Instructions and Memory Barriers" ], "previous_source": "", "target": [ "" ], "id_hash": 8971777210660439514, "content_hash": 8971777210660439514, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:66", "context": "", "note": "type: Title ===", "flags": "no-wrap", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 8, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 5, "source_unit": "https://translate-dev.freebsd.org/api/units/1134176/?format=api", "priority": 100, "id": 1761588, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=fc8227d6ad5c45da", "url": "https://translate-dev.freebsd.org/api/units/1761588/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.692106Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "There are several existing treatments of memory barriers and atomic instructions, so this section will not include a lot of detail. To put it simply, one can not go around reading variables without a lock if a lock is used to protect writes to that variable. This becomes obvious when you consider that memory barriers simply determine relative order of memory operations; they do not make any guarantee about timing of memory operations. That is, a memory barrier does not force the contents of a CPU's local cache or store buffer to flush. Instead, the memory barrier at lock release simply ensures that all writes to the protected data will be visible to other CPU's or devices if the write to release the lock is visible. The CPU is free to keep that data in its cache or store buffer as long as it wants. However, if another CPU performs an atomic instruction on the same datum, the first CPU must guarantee that the updated value is made visible to the second CPU along with any other operations that memory barriers may require." ], "previous_source": "", "target": [ "" ], "id_hash": 4667846920451657231, "content_hash": 4667846920451657231, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:69", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 9, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 183, "source_unit": "https://translate-dev.freebsd.org/api/units/1134178/?format=api", "priority": 100, "id": 1761589, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=c0c7860af76c0e0f", "url": "https://translate-dev.freebsd.org/api/units/1761589/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.692796Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "For example, assuming a simple model where data is considered visible when it is in main memory (or a global cache), when an atomic instruction is triggered on one CPU, other CPU's store buffers and caches must flush any writes to that same cache line along with any pending operations behind a memory barrier." ], "previous_source": "", "target": [ "" ], "id_hash": 3642835636987959963, "content_hash": 3642835636987959963, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:71", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 10, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 54, "source_unit": "https://translate-dev.freebsd.org/api/units/1134180/?format=api", "priority": 100, "id": 1761590, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=b28df3b615cd1a9b", "url": "https://translate-dev.freebsd.org/api/units/1761590/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.693618Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "This requires one to take special care when using an item protected by atomic instructions. For example, in the sleep mutex implementation, we have to use an `atomic_cmpset` rather than an `atomic_set` to turn on the `MTX_CONTESTED` bit. The reason is that we read the value of `mtx_lock` into a variable and then make a decision based on that read. However, the value we read may be stale, or it may change while we are making our decision. Thus, when the `atomic_set` executed, it may end up setting the bit on another value than the one we made the decision on. Thus, we have to use an `atomic_cmpset` to set the value only if the value we made the decision on is up-to-date and valid." ], "previous_source": "", "target": [ "" ], "id_hash": 3413074382387017462, "content_hash": 3413074382387017462, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:73", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 11, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 125, "source_unit": "https://translate-dev.freebsd.org/api/units/1134182/?format=api", "priority": 100, "id": 1761591, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=af5dad114a29f6f6", "url": "https://translate-dev.freebsd.org/api/units/1761591/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.694460Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Finally, atomic instructions only allow one item to be updated or read. If one needs to atomically update several items, then a lock must be used instead. For example, if two counters must be read and have values that are consistent relative to each other, then those counters must be protected by a lock rather than by separate atomic instructions." ], "previous_source": "", "target": [ "" ], "id_hash": -479607699138398771, "content_hash": -479607699138398771, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:75", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 12, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 60, "source_unit": "https://translate-dev.freebsd.org/api/units/1134184/?format=api", "priority": 100, "id": 1761592, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=79581756b55035cd", "url": "https://translate-dev.freebsd.org/api/units/1761592/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.695240Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Read Locks Versus Write Locks" ], "previous_source": "", "target": [ "" ], "id_hash": 3839873069012099358, "content_hash": 3839873069012099358, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:76", "context": "", "note": "type: Title ===", "flags": "no-wrap", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 13, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 5, "source_unit": "https://translate-dev.freebsd.org/api/units/1134186/?format=api", "priority": 100, "id": 1761593, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=b549f836350e211e", "url": "https://translate-dev.freebsd.org/api/units/1761593/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.695962Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Read locks do not need to be as strong as write locks. Both types of locks need to ensure that the data they are accessing is not stale. However, only write access requires exclusive access. Multiple threads can safely read a value. Using different types of locks for reads and writes can be implemented in a number of ways." ], "previous_source": "", "target": [ "" ], "id_hash": 6719598516729517991, "content_hash": 6719598516729517991, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:79", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 14, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 59, "source_unit": "https://translate-dev.freebsd.org/api/units/1134188/?format=api", "priority": 100, "id": 1761594, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=dd40cf3fbee797a7", "url": "https://translate-dev.freebsd.org/api/units/1761594/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.696643Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "First, sx locks can be used in this manner by using an exclusive lock when writing and a shared lock when reading. This method is quite straightforward." ], "previous_source": "", "target": [ "" ], "id_hash": -3152211437227272785, "content_hash": -3152211437227272785, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:81", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 15, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 27, "source_unit": "https://translate-dev.freebsd.org/api/units/1134190/?format=api", "priority": 100, "id": 1761595, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=54411866232515af", "url": "https://translate-dev.freebsd.org/api/units/1761595/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.697343Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "A second method is a bit more obscure. You can protect a datum with multiple locks. Then for reading that data you simply need to have a read lock of one of the locks. However, to write to the data, you need to have a write lock of all of the locks. This can make writing rather expensive but can be useful when data is accessed in various ways. For example, the parent process pointer is protected by both the `proctree_lock` sx lock and the per-process mutex. Sometimes the proc lock is easier as we are just checking to see who a parent of a process is that we already have locked. However, other places such as `inferior` need to walk the tree of processes via parent pointers and locking each process would be prohibitive as well as a pain to guarantee that the condition you are checking remains valid for both the check and the actions taken as a result of the check." ], "previous_source": "", "target": [ "" ], "id_hash": 8511388188322747696, "content_hash": 8511388188322747696, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:83", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 16, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 164, "source_unit": "https://translate-dev.freebsd.org/api/units/1134192/?format=api", "priority": 100, "id": 1761596, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=f61e8676466ed530", "url": "https://translate-dev.freebsd.org/api/units/1761596/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.698042Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Locking Conditions and Results" ], "previous_source": "", "target": [ "" ], "id_hash": -5636995876211773366, "content_hash": -5636995876211773366, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:84", "context": "", "note": "type: Title ===", "flags": "no-wrap", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 17, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 4, "source_unit": "https://translate-dev.freebsd.org/api/units/1134194/?format=api", "priority": 100, "id": 1761597, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=31c55e1dde0e304a", "url": "https://translate-dev.freebsd.org/api/units/1761597/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.698856Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "If you need a lock to check the state of a variable so that you can take an action based on the state you read, you can not just hold the lock while reading the variable and then drop the lock before you act on the value you read. Once you drop the lock, the variable can change rendering your decision invalid. Thus, you must hold the lock both while reading the variable and while performing the action as a result of the test." ], "previous_source": "", "target": [ "" ], "id_hash": 4129941161766870785, "content_hash": 4129941161766870785, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:87", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 18, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 84, "source_unit": "https://translate-dev.freebsd.org/api/units/1134196/?format=api", "priority": 100, "id": 1761598, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=b9507f9af260df01", "url": "https://translate-dev.freebsd.org/api/units/1761598/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.699534Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "General Architecture and Design" ], "previous_source": "", "target": [ "" ], "id_hash": 5933115187828741656, "content_hash": 5933115187828741656, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:89", "context": "", "note": "type: Title ==", "flags": "no-wrap", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 19, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 4, "source_unit": "https://translate-dev.freebsd.org/api/units/1134198/?format=api", "priority": 100, "id": 1761599, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=d256a8d40e01d618", "url": "https://translate-dev.freebsd.org/api/units/1761599/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.700247Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Interrupt Handling" ], "previous_source": "", "target": [ "" ], "id_hash": -7610166259328719743, "content_hash": -7610166259328719743, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:91", "context": "", "note": "type: Title ===", "flags": "no-wrap", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 20, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 2, "source_unit": "https://translate-dev.freebsd.org/api/units/1134200/?format=api", "priority": 100, "id": 1761600, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=1663421b870c6481", "url": "https://translate-dev.freebsd.org/api/units/1761600/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.700917Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Following the pattern of several other multi-threaded UNIX(R) kernels, FreeBSD deals with interrupt handlers by giving them their own thread context. Providing a context for interrupt handlers allows them to block on locks. To help avoid latency, however, interrupt threads run at real-time kernel priority. Thus, interrupt handlers should not execute for very long to avoid starving other kernel threads. In addition, since multiple handlers may share an interrupt thread, interrupt handlers should not sleep or use a sleepable lock to avoid starving another interrupt handler." ], "previous_source": "", "target": [ "" ], "id_hash": 2742999203787513451, "content_hash": 2742999203787513451, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:94", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 21, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 86, "source_unit": "https://translate-dev.freebsd.org/api/units/1134202/?format=api", "priority": 100, "id": 1761601, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=a611173e28ef1e6b", "url": "https://translate-dev.freebsd.org/api/units/1761601/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.701568Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "The interrupt threads currently in FreeBSD are referred to as heavyweight interrupt threads. They are called this because switching to an interrupt thread involves a full context switch. In the initial implementation, the kernel was not preemptive and thus interrupts that interrupted a kernel thread would have to wait until the kernel thread blocked or returned to userland before they would have an opportunity to run." ], "previous_source": "", "target": [ "" ], "id_hash": 8345770039116664396, "content_hash": 8345770039116664396, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:96", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 22, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 66, "source_unit": "https://translate-dev.freebsd.org/api/units/1134204/?format=api", "priority": 100, "id": 1761602, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=f3d221a1fea58e4c", "url": "https://translate-dev.freebsd.org/api/units/1761602/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.702272Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "To deal with the latency problems, the kernel in FreeBSD has been made preemptive. Currently, we only preempt a kernel thread when we release a sleep mutex or when an interrupt comes in. However, the plan is to make the FreeBSD kernel fully preemptive as described below." ], "previous_source": "", "target": [ "" ], "id_hash": -7624886595071531961, "content_hash": -7624886595071531961, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:98", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 23, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 47, "source_unit": "https://translate-dev.freebsd.org/api/units/1134206/?format=api", "priority": 100, "id": 1761603, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=162ef60a481fa447", "url": "https://translate-dev.freebsd.org/api/units/1761603/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.702980Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Not all interrupt handlers execute in a thread context. Instead, some handlers execute directly in primary interrupt context. These interrupt handlers are currently misnamed \"fast\" interrupt handlers since the `INTR_FAST` flag used in earlier versions of the kernel is used to mark these handlers. The only interrupts which currently use these types of interrupt handlers are clock interrupts and serial I/O device interrupts. Since these handlers do not have their own context, they may not acquire blocking locks and thus may only use spin mutexes." ], "previous_source": "", "target": [ "" ], "id_hash": 6868866715462382615, "content_hash": 6868866715462382615, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:100", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 24, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 85, "source_unit": "https://translate-dev.freebsd.org/api/units/1134208/?format=api", "priority": 100, "id": 1761604, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=df531de288a3b417", "url": "https://translate-dev.freebsd.org/api/units/1761604/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.703676Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Finally, there is one optional optimization that can be added in MD code called lightweight context switches. Since an interrupt thread executes in a kernel context, it can borrow the vmspace of any process. Thus, in a lightweight context switch, the switch to the interrupt thread does not switch vmspaces but borrows the vmspace of the interrupted thread. In order to ensure that the vmspace of the interrupted thread does not disappear out from under us, the interrupted thread is not allowed to execute until the interrupt thread is no longer borrowing its vmspace. This can happen when the interrupt thread either blocks or finishes. If an interrupt thread blocks, then it will use its own context when it is made runnable again. Thus, it can release the interrupted thread." ], "previous_source": "", "target": [ "" ], "id_hash": 5504032643905305855, "content_hash": 5504032643905305855, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:102", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 25, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 130, "source_unit": "https://translate-dev.freebsd.org/api/units/1134210/?format=api", "priority": 100, "id": 1761605, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=cc6240872c213cff", "url": "https://translate-dev.freebsd.org/api/units/1761605/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.704389Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "The cons of this optimization are that they are very machine specific and complex and thus only worth the effort if their is a large performance improvement. At this point it is probably too early to tell, and in fact, will probably hurt performance as almost all interrupt handlers will immediately block on Giant and require a thread fix-up when they block. Also, an alternative method of interrupt handling has been proposed by Mike Smith that works like so:" ], "previous_source": "", "target": [ "" ], "id_hash": -303862744160159044, "content_hash": -303862744160159044, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:104", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 26, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 79, "source_unit": "https://translate-dev.freebsd.org/api/units/1134212/?format=api", "priority": 100, "id": 1761606, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=7bc87671b1dbbabc", "url": "https://translate-dev.freebsd.org/api/units/1761606/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.705121Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Each interrupt handler has two parts: a predicate which runs in primary interrupt context and a handler which runs in its own thread context." ], "previous_source": "", "target": [ "" ], "id_hash": 7726467565623948429, "content_hash": 7726467565623948429, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:106", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 27, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 24, "source_unit": "https://translate-dev.freebsd.org/api/units/1134214/?format=api", "priority": 100, "id": 1761607, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=eb39ed507997b48d", "url": "https://translate-dev.freebsd.org/api/units/1761607/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.705842Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "If an interrupt handler has a predicate, then when an interrupt is triggered, the predicate is run. If the predicate returns true then the interrupt is assumed to be fully handled and the kernel returns from the interrupt. If the predicate returns false or there is no predicate, then the threaded handler is scheduled to run." ], "previous_source": "", "target": [ "" ], "id_hash": -4915243112679639315, "content_hash": -4915243112679639315, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:107", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 28, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 56, "source_unit": "https://translate-dev.freebsd.org/api/units/1134216/?format=api", "priority": 100, "id": 1761608, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=3bc98c6e5c0b76ed", "url": "https://translate-dev.freebsd.org/api/units/1761608/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.706551Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Fitting light weight context switches into this scheme might prove rather complicated. Since we may want to change to this scheme at some point in the future, it is probably best to defer work on light weight context switches until we have settled on the final interrupt handling architecture and determined how light weight context switches might or might not fit into it." ], "previous_source": "", "target": [ "" ], "id_hash": 1748165472498090935, "content_hash": 1748165472498090935, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:109", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 29, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 63, "source_unit": "https://translate-dev.freebsd.org/api/units/1134218/?format=api", "priority": 100, "id": 1761609, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=9842bb3c2cda03b7", "url": "https://translate-dev.freebsd.org/api/units/1761609/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.707215Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Kernel Preemption and Critical Sections" ], "previous_source": "", "target": [ "" ], "id_hash": -1736427204040049588, "content_hash": -1736427204040049588, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:110", "context": "", "note": "type: Title ===", "flags": "no-wrap", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 30, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 5, "source_unit": "https://translate-dev.freebsd.org/api/units/1134220/?format=api", "priority": 100, "id": 1761610, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=67e6f8a86cde3c4c", "url": "https://translate-dev.freebsd.org/api/units/1761610/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.707878Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Kernel Preemption in a Nutshell" ], "previous_source": "", "target": [ "" ], "id_hash": -7262069130727941492, "content_hash": -7262069130727941492, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:112", "context": "", "note": "type: Title ====", "flags": "no-wrap", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 31, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 5, "source_unit": "https://translate-dev.freebsd.org/api/units/1134222/?format=api", "priority": 100, "id": 1761611, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=1b37f29a08a19a8c", "url": "https://translate-dev.freebsd.org/api/units/1761611/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.708527Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Kernel preemption is fairly simple. The basic idea is that a CPU should always be doing the highest priority work available. Well, that is the ideal at least. There are a couple of cases where the expense of achieving the ideal is not worth being perfect." ], "previous_source": "", "target": [ "" ], "id_hash": -8184681061848025606, "content_hash": -8184681061848025606, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:115", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 32, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 46, "source_unit": "https://translate-dev.freebsd.org/api/units/1134224/?format=api", "priority": 100, "id": 1761612, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=0e6a2bf044ae75fa", "url": "https://translate-dev.freebsd.org/api/units/1761612/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.709152Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Implementing full kernel preemption is very straightforward: when you schedule a thread to be executed by putting it on a run queue, you check to see if its priority is higher than the currently executing thread. If so, you initiate a context switch to that thread." ], "previous_source": "", "target": [ "" ], "id_hash": -3596768486781175441, "content_hash": -3596768486781175441, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:117", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 33, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 46, "source_unit": "https://translate-dev.freebsd.org/api/units/1134226/?format=api", "priority": 100, "id": 1761613, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=4e15b61e2616b96f", "url": "https://translate-dev.freebsd.org/api/units/1761613/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.709809Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "While locks can protect most data in the case of a preemption, not all of the kernel is preemption safe. For example, if a thread holding a spin mutex preempted and the new thread attempts to grab the same spin mutex, the new thread may spin forever as the interrupted thread may never get a chance to execute. Also, some code such as the code to assign an address space number for a process during `exec` on the Alpha needs to not be preempted as it supports the actual context switch code. Preemption is disabled for these code sections by using a critical section." ], "previous_source": "", "target": [ "" ], "id_hash": -4476678145260551362, "content_hash": -4476678145260551362, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:119", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 34, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 104, "source_unit": "https://translate-dev.freebsd.org/api/units/1134228/?format=api", "priority": 100, "id": 1761614, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=41dfa4f201fd833e", "url": "https://translate-dev.freebsd.org/api/units/1761614/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.710512Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Critical Sections" ], "previous_source": "", "target": [ "" ], "id_hash": 8822674996579536879, "content_hash": 8822674996579536879, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:120", "context": "", "note": "type: Title ====", "flags": "no-wrap", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 35, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 2, "source_unit": "https://translate-dev.freebsd.org/api/units/1134230/?format=api", "priority": 100, "id": 1761615, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=fa70702a33d80fef", "url": "https://translate-dev.freebsd.org/api/units/1761615/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.711223Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "The responsibility of the critical section API is to prevent context switches inside of a critical section. With a fully preemptive kernel, every `setrunqueue` of a thread other than the current thread is a preemption point. One implementation is for `critical_enter` to set a per-thread flag that is cleared by its counterpart. If `setrunqueue` is called with this flag set, it does not preempt regardless of the priority of the new thread relative to the current thread. However, since critical sections are used in spin mutexes to prevent context switches and multiple spin mutexes can be acquired, the critical section API must support nesting. For this reason the current implementation uses a nesting count instead of a single per-thread flag." ], "previous_source": "", "target": [ "" ], "id_hash": 5362449329766157858, "content_hash": 5362449329766157858, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:123", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 36, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 120, "source_unit": "https://translate-dev.freebsd.org/api/units/1134232/?format=api", "priority": 100, "id": 1761616, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=ca6b3f4102be4e22", "url": "https://translate-dev.freebsd.org/api/units/1761616/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.711856Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "In order to minimize latency, preemptions inside of a critical section are deferred rather than dropped. If a thread that would normally be preempted to is made runnable while the current thread is in a critical section, then a per-thread flag is set to indicate that there is a pending preemption. When the outermost critical section is exited, the flag is checked. If the flag is set, then the current thread is preempted to allow the higher priority thread to run." ], "previous_source": "", "target": [ "" ], "id_hash": 4614886110510490439, "content_hash": 4614886110510490439, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:125", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 37, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 81, "source_unit": "https://translate-dev.freebsd.org/api/units/1134234/?format=api", "priority": 100, "id": 1761617, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=c00b5e777fdca347", "url": "https://translate-dev.freebsd.org/api/units/1761617/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.712598Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Interrupts pose a problem with regards to spin mutexes. If a low-level interrupt handler needs a lock, it needs to not interrupt any code needing that lock to avoid possible data structure corruption. Currently, providing this mechanism is piggybacked onto critical section API by means of the `cpu_critical_enter` and `cpu_critical_exit` functions. Currently this API disables and re-enables interrupts on all of FreeBSD's current platforms. This approach may not be purely optimal, but it is simple to understand and simple to get right. Theoretically, this second API need only be used for spin mutexes that are used in primary interrupt context. However, to make the code simpler, it is used for all spin mutexes and even all critical sections. It may be desirable to split out the MD API from the MI API and only use it in conjunction with the MI API in the spin mutex implementation. If this approach is taken, then the MD API likely would need a rename to show that it is a separate API." ], "previous_source": "", "target": [ "" ], "id_hash": 75582939216119995, "content_hash": 75582939216119995, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:127", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 38, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 169, "source_unit": "https://translate-dev.freebsd.org/api/units/1134236/?format=api", "priority": 100, "id": 1761618, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=810c8648630e88bb", "url": "https://translate-dev.freebsd.org/api/units/1761618/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.713303Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Design Tradeoffs" ], "previous_source": "", "target": [ "" ], "id_hash": -7663982619355991287, "content_hash": -7663982619355991287, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:128", "context": "", "note": "type: Title ====", "flags": "no-wrap", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 39, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 2, "source_unit": "https://translate-dev.freebsd.org/api/units/1134238/?format=api", "priority": 100, "id": 1761619, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=15a41069c884b309", "url": "https://translate-dev.freebsd.org/api/units/1761619/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.714059Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "As mentioned earlier, a couple of trade-offs have been made to sacrifice cases where perfect preemption may not always provide the best performance." ], "previous_source": "", "target": [ "" ], "id_hash": -1147960678977475574, "content_hash": -1147960678977475574, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:131", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 40, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 23, "source_unit": "https://translate-dev.freebsd.org/api/units/1134240/?format=api", "priority": 100, "id": 1761620, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=70119fd8396e6c0a", "url": "https://translate-dev.freebsd.org/api/units/1761620/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.714677Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "The first trade-off is that the preemption code does not take other CPUs into account. Suppose we have a two CPU's A and B with the priority of A's thread as 4 and the priority of B's thread as 2. If CPU B makes a thread with priority 1 runnable, then in theory, we want CPU A to switch to the new thread so that we will be running the two highest priority runnable threads. However, the cost of determining which CPU to enforce a preemption on as well as actually signaling that CPU via an IPI along with the synchronization that would be required would be enormous. Thus, the current code would instead force CPU B to switch to the higher priority thread. Note that this still puts the system in a better position as CPU B is executing a thread of priority 1 rather than a thread of priority 2." ], "previous_source": "", "target": [ "" ], "id_hash": 200729215914738445, "content_hash": 200729215914738445, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:133", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 41, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 152, "source_unit": "https://translate-dev.freebsd.org/api/units/1134242/?format=api", "priority": 100, "id": 1761621, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=82c922288aa4030d", "url": "https://translate-dev.freebsd.org/api/units/1761621/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.715355Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "The second trade-off limits immediate kernel preemption to real-time priority kernel threads. In the simple case of preemption defined above, a thread is always preempted immediately (or as soon as a critical section is exited) if a higher priority thread is made runnable. However, many threads executing in the kernel only execute in a kernel context for a short time before either blocking or returning to userland. Thus, if the kernel preempts these threads to run another non-realtime kernel thread, the kernel may switch out the executing thread just before it is about to sleep or execute. The cache on the CPU must then adjust to the new thread. When the kernel returns to the preempted thread, it must refill all the cache information that was lost. In addition, two extra context switches are performed that could be avoided if the kernel deferred the preemption until the first thread blocked or returned to userland. Thus, by default, the preemption code will only preempt immediately if the higher priority thread is a real-time priority thread." ], "previous_source": "", "target": [ "" ], "id_hash": 3484355505268437952, "content_hash": 3484355505268437952, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:135", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 42, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 174, "source_unit": "https://translate-dev.freebsd.org/api/units/1134244/?format=api", "priority": 100, "id": 1761622, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=b05aeadf02b3b3c0", "url": "https://translate-dev.freebsd.org/api/units/1761622/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.716107Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Turning on full kernel preemption for all kernel threads has value as a debugging aid since it exposes more race conditions. It is especially useful on UP systems were many races are hard to simulate otherwise. Thus, there is a kernel option `FULL_PREEMPTION` to enable preemption for all kernel threads that can be used for debugging purposes." ], "previous_source": "", "target": [ "" ], "id_hash": -6881994066883189399, "content_hash": -6881994066883189399, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:137", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 43, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 57, "source_unit": "https://translate-dev.freebsd.org/api/units/1134246/?format=api", "priority": 100, "id": 1761623, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=207e3edbc914e569", "url": "https://translate-dev.freebsd.org/api/units/1761623/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.716855Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Thread Migration" ], "previous_source": "", "target": [ "" ], "id_hash": -3832919050119234645, "content_hash": -3832919050119234645, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:138", "context": "", "note": "type: Title ===", "flags": "no-wrap", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 44, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 2, "source_unit": "https://translate-dev.freebsd.org/api/units/1134248/?format=api", "priority": 100, "id": 1761624, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=4acebc6e7cd0bbab", "url": "https://translate-dev.freebsd.org/api/units/1761624/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.717512Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Simply put, a thread migrates when it moves from one CPU to another. In a non-preemptive kernel this can only happen at well-defined points such as when calling `msleep` or returning to userland. However, in the preemptive kernel, an interrupt can force a preemption and possible migration at any time. This can have negative affects on per-CPU data since with the exception of `curthread` and `curpcb` the data can change whenever you migrate. Since you can potentially migrate at any time this renders unprotected per-CPU data access rather useless. Thus it is desirable to be able to disable migration for sections of code that need per-CPU data to be stable." ], "previous_source": "", "target": [ "" ], "id_hash": 5639549270827207817, "content_hash": 5639549270827207817, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:141", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 45, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 110, "source_unit": "https://translate-dev.freebsd.org/api/units/1134250/?format=api", "priority": 100, "id": 1761625, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=ce43b42ea4f80c89", "url": "https://translate-dev.freebsd.org/api/units/1761625/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.718194Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Critical sections currently prevent migration since they do not allow context switches. However, this may be too strong of a requirement to enforce in some cases since a critical section also effectively blocks interrupt threads on the current processor. As a result, another API has been provided to allow the current thread to indicate that if it preempted it should not migrate to another CPU." ], "previous_source": "", "target": [ "" ], "id_hash": -2910145824166334305, "content_hash": -2910145824166334305, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:143", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 46, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 65, "source_unit": "https://translate-dev.freebsd.org/api/units/1134252/?format=api", "priority": 100, "id": 1761626, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=579d15caa1fab09f", "url": "https://translate-dev.freebsd.org/api/units/1761626/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.718926Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "This API is known as thread pinning and is provided by the scheduler. The API consists of two functions: `sched_pin` and `sched_unpin`. These functions manage a per-thread nesting count `td_pinned`. A thread is pinned when its nesting count is greater than zero and a thread starts off unpinned with a nesting count of zero. Each scheduler implementation is required to ensure that pinned threads are only executed on the CPU that they were executing on when the `sched_pin` was first called. Since the nesting count is only written to by the thread itself and is only read by other threads when the pinned thread is not executing but while `sched_lock` is held, then `td_pinned` does not need any locking. The `sched_pin` function increments the nesting count and `sched_unpin` decrements the nesting count. Note that these functions only operate on the current thread and bind the current thread to the CPU it is executing on at the time. To bind an arbitrary thread to a specific CPU, the `sched_bind` and `sched_unbind` functions should be used instead." ], "previous_source": "", "target": [ "" ], "id_hash": 6114234319276565654, "content_hash": 6114234319276565654, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:145", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 47, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 175, "source_unit": "https://translate-dev.freebsd.org/api/units/1134254/?format=api", "priority": 100, "id": 1761627, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=d4da1fb801fb6496", "url": "https://translate-dev.freebsd.org/api/units/1761627/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.719633Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "Callouts" ], "previous_source": "", "target": [ "" ], "id_hash": 1068506298222368858, "content_hash": 1068506298222368858, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:146", "context": "", "note": "type: Title ===", "flags": "no-wrap", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 48, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 1, "source_unit": "https://translate-dev.freebsd.org/api/units/1134256/?format=api", "priority": 100, "id": 1761628, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=8ed418d129cfd85a", "url": "https://translate-dev.freebsd.org/api/units/1761628/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.720383Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "The `timeout` kernel facility permits kernel services to register functions for execution as part of the `softclock` software interrupt. Events are scheduled based on a desired number of clock ticks, and callbacks to the consumer-provided function will occur at approximately the right time." ], "previous_source": "", "target": [ "" ], "id_hash": -2117495943706672038, "content_hash": -2117495943706672038, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:149", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 49, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 43, "source_unit": "https://translate-dev.freebsd.org/api/units/1134258/?format=api", "priority": 100, "id": 1761629, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=629d24a87e08845a", "url": "https://translate-dev.freebsd.org/api/units/1761629/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.721012Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/booksarch-handbooksmp_index/fr/?format=api", "source": [ "The global list of pending timeout events is protected by a global spin mutex, `callout_lock`; all access to the timeout list must be performed with this mutex held. When `softclock` is woken up, it scans the list of pending timeouts for those that should fire. In order to avoid lock order reversal, the `softclock` thread will release the `callout_lock` mutex when invoking the provided `timeout` callback function. If the `CALLOUT_MPSAFE` flag was not set during registration, then Giant will be grabbed before invoking the callout, and then released afterwards. The `callout_lock` mutex will be re-grabbed before proceeding. The `softclock` code is careful to leave the list in a consistent state while releasing the mutex. If `DIAGNOSTIC` is enabled, then the time taken to execute each function is measured, and a warning is generated if it exceeds a threshold." ], "previous_source": "", "target": [ "" ], "id_hash": 8089060480249487509, "content_hash": 8089060480249487509, "location": "documentation/content/en/books/arch-handbook/smp/_index.adoc:151", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 0, "fuzzy": false, "translated": false, "approved": false, "position": 50, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 138, "source_unit": "https://translate-dev.freebsd.org/api/units/1134260/?format=api", "priority": 100, "id": 1761630, "web_url": "https://translate-dev.freebsd.org/translate/documentation/booksarch-handbooksmp_index/fr/?checksum=f0421da62bebe095", "url": "https://translate-dev.freebsd.org/api/units/1761630/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2025-01-22T18:20:33.721685Z" } ] }