4.7.

Kiểm tra tính năng

Trước khi sử dụng công cụ hiệu chỉnh tích hợp, một ý tưởng tốt là kiểm
tra lại tổng thể sự thực thi của hệ thống của chúng ta và xác định nó phù hợp
cho ứng dụng thời gian thực. Vì vậy vấn đầu kiểm tra chạy gầm định là thay
đổi cho chế độ nhân và người dùng. Nó kiểm tra cấu trúc đợi và biến động, của
lịch trình thực hiện một task (nhiệm vụ). Khi sử dụng timer cứng trong chế độ
oneshot, nó có thể phục vụ làm điều chỉnh mịn thời gian thực trung bình của
hang đợi gầm. Trong chế độ oneshot ý tưởng là để do sự khác nhau về thời gian
giữa thời gian chuyển đổi và thời gian khi nhiệm vụ chính xác được gọi bởi
hành đợi. Trong chế độ periodic mặc dù sự thay đổi của thời điểm nhiệm vụ là
được sử dụng để đo đợi/trễ của hành đợi. Lý do để lựa chọn là khác nhau bởi vì
ngắt thời gian dựa trên đường thời gian cơ bản cái khác nhau từ một cái sử
đụng để mang sự tính toán đo lường; trong trường hợp rất tốt (trong mục tiếp
theo) như sự khác nhau có thể là rất nhỏ và xa hơn khi không có sự mất thời
gian ngắt sẽ không có sự khác nhau trong chế độ periodic, nếu như phần cứng
bị nặng, thì sự thay đổi thời điểm là giá trị co ý nghĩa. Sự thực hiện là đầy đủ
chọn lựa tại thời gian chèn vào như cài đặt có thể, chế độ thời gian, thời gian
chu kỳ, thời gian trung bình và thời gian trung bình phần trăm hoặc trường hợp
quá tồi và sử dụng FPU (với vài sự tính toán). Kiểm tra này được cục bộ hóa,
sau khi cài đặt RTAI trong mục install_dir/testsuite/kern/latency hoặc
install_dir/testsuite/user/latency. Chạy script ./run sẽ bắt đầu và kết quả như
sau:
Như bạn nhìn thấy trong ví dụ này kiểm tra cho kết quả tồi, với sự quan sát là
không thể chấp nhận được cho ứng dụng thời gian thực. Để hiểu hơn tại sao cái
này có thể sảy ra bạn có thể báo trước “latency killer” điều kiện có thể là trong
hệ thống của bạn. Chúng là:
- Hoạt động DMA nặng ( như điều khiển đĩa cứng hoặc các thiết bị
PCI khác).
- Sự sử dụng của x-server
- Hỗ trợ USB gầm.
- Quả lý nguồn (của APM và ACPI)
- Tính toán tần số CPU.
- SMI
- Cắm các nhiều thiết bị khác.
Sự loại bỏ “latency” là nguyên nhân không dự báo trước thời gian kết quả và là
không thuận tiện với thời gian thực. Như bạn có thể bỏ chúng trong của BIOS
và trong cài đặt nhân. Bạn có thể tìm thấy thông tin trong làm thế nào để loại
các chức năng ở mức nhân trong linux/Documentation Kernel-parameters.txt.
Khi bạn đã loại bỏ những nghi ngờ lien quan tới “latency killer” chạy test lại
nếu có lỗi xảy ra.

Trong minh họa ở trên, sau khi loại bỏ DMA cho đĩa cứng, kiểm tra chế độ chờ
là nhuần nhuyễn không có quá thời gian và thực hiện có thể chấp nhận.
Tất cả kết quả hiện thị bởi kiểm tra chế độ chờ là nano giây. Nó là ý
tưởng tốt để chạy kiểm trong thời gian chu kỳ dài trong khi hệ thống ép nặng,
như khi ghi đĩa, truy cập mạng và sử dụng giao diện đồ họa để nhận được thời
gian cản trở của hệ thống bạn và để tìm ra các những cái có thể them nguồn của
hệ thống. Một kiểm tra thành công bạn có thể sử lý để có thể thử giảm chờ và
nhận được nhiều tất định của hệ thống hơn.

Chú ý: Luôn chạy kiểm tra cả hai (kernel/user) để hiểu được hoàn toàn sự trễ
của hệ thống. Trong chế độ người dùng bạn có thể loại kết quả tồi nhỏ, nhưng
không quá xấu, so sánh nó với nhân.
4.7..1. Kiểm tra chuyển khóa.
Đây là một công cụ kiểm tra quan trọng khác, đặc trong thư mục
testsuite, cái này cung cấp cho bạn những thông tin về thời gian lớn nhấn RTAI
cần để bỏ ngắt. Phần mền dưới testsuite/kern/switches ( hoặc user/switches) và
kiểm tra cho thời gian chuyển task. Để làm điều đó có ích lặp liên tục
treo/chiếm lại và cờ tín hiệu/đợi, với hỗ trợ FPU (với đơn vị dấu phảy động) và
dưới liên quan với tải nặng (khoảng 10 tasks). Giả sử nhân nhân đã được vá
thích hợp và chạy như miêu tả trước, kết quả đưa bạn một ý tưởng về kiến trúc
thời gian chuyển khóa. Nếu giá trị là quá cao bạn có thể thẩm định lại nếu có
bất kỳ bỏ trễ nào. Hơn nữa bạn sẽ nhìn thấy ảnh thời gian chuyển khóa ở dưới
là trường hợp trễ xấu nhất với sự chú ý tới một trễ sẽ được lấy bởi công cụ
kiểm tra nào của RTAI như trễ hàng được nhiệm vụ hoặc chỉ ngắt kiểm tra trễ,
đặc biệt làn nếu bất kỳ tải linux được sử dụng. Rõ ràng giới hạn trễ thực là
hiếm khi do RTAI nhưng là thực chất hạn ché của mục đích sử dụng CPU
chung cho ứng dụng thời gian thực. Để chạy kiển tra đơn giản này thực hiện
script ./run đặc trong thư mục. Bạn sẽ nhận được kết quả tương tự như sau:

4.7.2. kiểm tra preempt (quyền ưu tiên)

Đây là sự khiểm tra cuối cùng trong thư mục testsuite. Nó được thiết kế để
thẩm định lại biểu dưới tải mạnh. Bạn có thể nhìn thấy kiểm tra này như sự
căng thẳng có lợi. Phầm mền này kết hợp kiểm định trễ nhiệm vụ với nhiệm vụ
nhanh và chạm để có hai mức ưu tiên.Lồng một số lẻ các nhiệm vụ. Bạn có thể
thẩm định cái gì xảy ra bởi lợ ích hiệm thị cái mà sẽ hiện biến động lớn
nhất/nhỏ nhất/trung bình của kiểm tra trễ nhiệm vụ, tiếp theo tới ưu tiên cao
nhất và nhiệm vụ chậm, tại ưu tiên thấp nhất. Lý do có thể dao động là biểu thị
rõ của ưu tiên. Đây là kiểm tra trên UP machine dùng tới 75% năng lực tính
toán của máy bạn vì vậy bạng muốn giảm xung để nhận tải ít hơn. Nghĩa là bạn
có thể điều tham số của kiểm tra này theo đặc tả máy của bạn để tránh khóa
không đúng của biểu làm việc. Để ứng dụng thêm căng thẳng cho máy bạn có
thể muốn sử dụng ít nhất một trong những lệnh sau:
ping –f whatever.address.youlike
ping –f localhost
Phía trên cùng của màn hình và có thể trên màn hình X khác
a “while “true”; do ls –IR / > list; done”
a “while “true”; cat /proc/interrupts; done”
Khởi đầu ít nhất một lệnh dd được truy nhập đĩa cứng nặng.
Nó cũng đề nghị để chạy vài lần (it nhất vài giờ) to để lấy bức ảnh thực tế mấy
bạn. Kiểm tra này cũng ở trong thời mực user.
4.8. sử dụng công cụ kiểm định tích hợp cho cấu trúc i386
RTAI 3.x cung cấp công cụ kiểm tra mới, giúp bạn xác ddijjnh nếu nền tảng
phần cứng của bạn được nâng cấp tới năng suất thời gian thực cứng để điều
chỉnh nó tới tốt nhất. Bạn có thể tìm thấy duwowsic $installdir/calibration. Để
nhận được tất cả các lựa chọn đánh:
$./calibrate –help
Để chạy công cụ này theo các modules có thể đã nạp sẵn.
1) rtai_hal
2) rtai_lxtr or rtai_sched
3) rtai_fifos
4) rtai_calibrate
Chú ý: rtai_lxtr phải được chèn vào nếu bạn muốn kiểm tra (định cỡ) xa hơn
nữa dùng luồn linux trong nhân; trong khi rtai_sched là sử dụng nhiệm vụ nhân
RTAI đặc biệt, cùng với luồng trong nhân.
Bạn có thể cũng thực hiện script ./run để tự động nạp modules và vào
công cụ. Script này cũng truy nhập vài lựa chọn như: calibrate_irq và
calibrate_user.

Mục đích chính của công cụ kiểm tra là cho bạn thấy làm thế nào để điều
chính tốt hệ thống của bạn để lấy thông tinh và chế độ 8254 oneshot, tần số
CPU, tần số APIC, trễ và trường hợp khóa ngắt tồi nhất/sự tranh giành.
Đây là file README hoàn chỉnh ở thư mục base/arch/i386/calibration
chứa tất cả chi tiết về kiểm định nhưng tóm tắt chúng ta có thể nói kiểm định
8254 ước lượng thời gian nó mất để viết hai bytes vào bộ timer 8254. Kiểm tra
tần số CPU kiểm định clock cpu dựa vào bộ timer 8259. Bạn có thể chạy hai
kiểm tra với nhau đơn giản bởi đánh calibrate –b. Kiểm tra trễ Latency kiểm
định trễ lịch của bộ lập lịch RTAI với bộ thời gian một lần duy nhất (oneshot),
cho phép thấy rõ rành vời gian thực hiện nhiệm vụ (stacks). Kiểm tra quan
trọng cuối cùng là khóa/tranh chấp ngắt (calibrate –i); rất nhiều bo mạch mẹ là
được bán với chipset cái có tối ưu phần cứng cho phép khóa bus, có lẽ mất vài
milli giây. Không có sự phân sự như cách làm việc được chấp nhận, nó tạo ra
sự xuất hiện cải thiện hoàn toàn hiệu năng trung bình của ứng dụng chung, nó
chắc chắn phải chịu sự sử dụng thời gian thực. Bình thường cái gì RTAI sử
dụng, là dao động lịnh làm lớn và chúng bắt gợi ý lỗi như là không tồn tại.
Kiểm tra này là nhằm mục đích bắt các vần đề. Nó đo trễ ngắt bằng sử dụng
TSC trong bộ thời gian ngắt, máy không có TSC là đủ cũ để không có tối ưu
chipsets. Vì vậy chúng không có vấn đề như vậy. Chỉ có thực hiện module la
rtai.c, trong dó không có lịch nhưng giải quyết nhanh ngắt, cái đó có thời gian
trễ trong phạm vi 20/30 của trường hợp xấu nhất. Vì vậy nếu bạn nhìn thấy vài
cái quá lơn hơn sau đó chơi lại với các thông số cài đặt, với linux như tốt, và
bạn có thể kết thúc bằng mua bo mạch khác. Trễ ngắt xất nhất để kiểm tra nó
cũng trên vùng bằng sử dụng định nghĩa “-sy” và nối vùng tới đầu ra bít đầu
tiên của cổng song song.
Nhìn trong file README.SMI trong cùng thư mục cho vài manh mối
giúp đỡ với vài chip INTEL.
4.8.1. Chơi với sự thể hiện của công cụ kiểm tra.
Trong sự đáp ứng trưng bày đã được sửa phiên bản của công cụ kiểm tra;
nó khác với chuẩn chính bởi vì nó có thể kiểm định của RTAI ktasks và Linux
kthreads và nó nhiều tương tác và vì vậy dễ sử dụng hơn. Đây là kiểm tra ở:
showroom/v3.x/kern/i386/calibration.
 Tất cả các kiểm tra có thể chạy không cần thoát và khởi động lại xử lý,
vì vậy cho phép nhanh hơn và kiểm định rõ ràng hơn phần cứng của bạn.
Để kiểm tra kiểu đơn giản “Viết hoa ký tự” như thể hiện trong danh mục
và trèn vào, nếu yêu cầu, yêu cầu đặt các giá trị.
Với công cụ này bạn cũng có thể tìm được cái gì là thời điểm nhỏ nhất
máy có thể làm được không bị đông cứng. Kiểm tra này không thực tế cho
kiểm định phần cứng nhưng nó là quan trọng để bạn có ý tưởng về hiệu năng
lớn nhất có thể thực hiện được. Để khám phá giới hạn này, đơn giản chạy kiểm
tra khóa bus với giảm thời gian xuống để máy đông cứng.
Chú ý: Bạn có thể luôn luôn chạy kiểm tra thẩm định cho thời điểm lý do
có thể của thời gian và dưới tải hệ thống trung bình hoặc ít nhất có một cái tỷ
mỉ về hiệu năng thực hệ thống;
4.8.3. Làm gì với kết quả đó.
Như bạn đã học, các kết quả này sẽ được cho bạn một vài lời chỉ bảo cần
quan tâm về nền tảng phần cứng của bạn; bây giờ nó là quan trọng để dùng
chúng để chọn cài đặt RTAI để đạt được các giá trị thời gian tốt hơn. Đầu tiển
tất cả chúng ta cần phải hiểu sự kiện nếu kiển định là khồng cần thiết chặt trẽ,
như RTAI sẽ chạy không cần nó, nó là tốt hơn để cài đặt máy để nó tốt hơn vì
vậy bạn có thể lớn nhất từ nó. RTAI có vài định nghĩa, trong đó mã nguồn có
thể được dùng để gán đúng giá trị từ kiểm định. Các giá trị đó, như thời gian
cài đặt 8254, tần số APIC (nếu có APIC) và tần số CPU phải được chèn vào
bằng tay trong asm-i386/rtai_hal.h file trong khi định nghĩa trễ được định nghĩa
trong rtai_config.h file. Sau khi có vài sử đổi trong mã nguồn bạn có thể hiển
nhiên thấy được cần phải biên dịch lại và khởi động lại RTAI trước khi thay đổi
có tác dụng.

Có vài giá trị cũng có thể qua các modules, vì vậy tránh biên dịch lại
RTAI và cho phép dễ hơn/chuyển đổi (khả chuyển) cài đặt trên các máy khác.
Cài đặt thời gian và trễ có thể thông qua module lập lịch trong khi APIC và tần
số CPU tới module rtai_hal nhu ví dụ sau:
Lấy kết quả đưa ra từ calibrate –c với tần số CPU và đánh:
insmod rtai_hal.ko rtai_cpufreq_arg=996677084
Nếu có APIC chạy calibrate –a và qua kết quả rtai_hal với:
insmod rtai_hal.ko rtai_apicfreq_arg=VALUE_FOR_THE_APIC
Kiển định 8254 và trễ (calibrate –r và –k hoặc –u) có thể sẽ qua lập lịnh
rtai_ksched hoặc rtai_lxrt.
insmod rtai_lxrt.ko SetupTimeTIMER=xvalue Latency=yvalue
hoặc
insmod rtai_ksched.ko SetupTimeTIMER=xvalue Latency=yvalue
Chú ý: trễ có thể kiểm định để tìm ra giá trị trung bình cái phải có để cả
kernel và người dùng có thể chấp nhận được, nếu, như bạn báo trước, sự khác
nhau là rất nhỏ. Trong khi, nếu trong dự án RTAI của bạn, dựa trên cơ bản trên
kernel hoặc chỉ trên có độ người dùng, kiểm tra lại trễ cho lựa chọn lịch.
Cuối cùng bạn có thể muốn chạy lại kiểm tra trê và kiểm định để chắc
chán mức hiệu năng cuối cùng sau khi chỉnh sản phẩm.
5. Bộ lập lịch làm việc RTAI
Bộ lập lịch và thời gian làm việc cứng trong không gian kernel/user.
Bộ lập lịch là trái tim của RTAI, nó cung cấp rãnh một loạt cái máy kiểm
định thời gian thực với cái mà kỳ lạ dị thường với dự án này. Bằng cách sử
dụng bộ lập lịch RTAI bộ sử lý có thể gặp thời gian thực cứng ràng buộc và có
thể chạy để quyết định, có nghĩa là bộ sử lý có thể chạy chính xác như thiết kế
và không giới hạn bởi bộ lập lich GNU.Linux. Xử lý thời gian thực liên kết vơi
RTAI có thể vì vậy sử dụng để điều khiển các ứng dụng phức tạp, như điều
khiển số, xử lý công nghiệp và bất kỳ nhiệm vụ phức tạp nào với yêu cầu chính
xác lịch.
RTAI cung cấp cân đối thời gian thực phục vụ inter/intra không gian
user/kernel. Như công cấp quan hai bộ lập lịch, cái mà tại thời điểm được gọi
rtai_lxrt và rtai_sched. Chúng có thể hoạt động trong cả chế độ nhân và người
sử dụng và chúng khác chỉ trong quan hệ để các đối tượng có thể lập lịch.
Nghĩa là rtai_lxrt là sự đơn giản của bộ hành đợi GNU/Linux, nghĩa là nó có
cung cấp thời có gian thực cứng cho tất cả các lịch có thể như xử
ký/thread/kthreads. rtai_sched được phục vuk không chỉ thowfin gian thực
cứng cho tất cả các đối tượng lịch linux, như processes/threads/kthreads, nhưng
cũng cả các nhiệm vụ RTAI với nhân nhự chỉ có đối tượng thích đáng của
RTAI,.
Vì vậy trong khi trong không gian người dùng không có lựa chọn nhưng
lập lịch xử lý của linux và threads, một có thể hỏi cô hoặc anh ấy cái gì là tồi
phần thừ của có sự khó khăn lập lịch đối tượng trong không gian nhân, như lần
đầu lướt qua chúng ta sẽ có thể nhiêu chức năng tương tự. Sự hiểu nhưng tiện
lợi và không tiện lợi của một hàng đợi với sự kính trọng ngưỡng mộ các cái
quan trọng khác để giải quyết casci gì để sử dụng và làm thế nào bạn có thể làm
chủ thời gian thực của phần mềm. Làm ơn để ý là không gian người dùng chỉ
có những ứng dụng 2 bộ lập lịch là như nhau. Vì vậy ngợi ý không gian người
dùng nghĩa là LXRT là lỗi như RTAI trong LXRT. Tên khác nhau của bộ lập
lịch là để phân biệt hàn đợi đối tượng xác định trong không gian nhân và để dễ
cho cái muốn sử dụng lập lịch đối tượng linux và mọi nơi.
Do đó có thể nối ngay lập tức các tiện lợi lớn của RTAI nhân nhiệm vụ
là thời gian chuyển khoác nhanh với nhiệm vụ nhân linux, nhưng mặt khác nó
là quan trọng để hiểu là chúng hoạt động ngoài bất kỳ môi trường nào. Sự
chuyển đổi này đòi hỏi vài chú ý đặc biết nếu nó cần để liên quan hoạt động với
linux. Điều đánh chú ý là không phải trả với nhân linux như chúng trả giá tiện
lợi tích hợp đầy đủ trong môi trường linux và cần RTAI linux ảnh hưởn nhau;
hoặc ít nhất là một cái gì đưa ra nhiều thoải mãi để phát triển.
5.1. Làm thể nào để bộ lập biểu hoạt động
Đã nói nhìn đầu tiên như thết nào bất kỳ của 2 xác định bộ lập lịch của
RTAI có thể trở thành bộ lập lịch nhử của đối tượng linux lập lịch, Ám chỉ
chúng ta khác trong bộ sự lý, bạt biết để xây dựng nó chắc chắn: khởi nhập nó
bằng đánh tên nó, thông qua scipts shell, chặc, thread người dùng, đã tạo ra bởi
pthread_create hoặc bản sao, nhân thread. sự tạo bởi nhân thread hoặc nhữ hỗ
trợ chức năng mới hơn được tìm thấy trong 2.6.xx. Sau đó sử dụng RTAI bạn
cần mở rộng cấu trúc nhiệm vụ Linux , bởi liên kết nó với RTAI. Cái đó được
dùng bởi:
 - rt_task_init_schmod (hoặc rt_tasj_init, là đơn giản hơn như giới hạn)
chỉ trong không gian người dùng.
- set_rtext trong không gian nhân, nhưng bạn không bao giởi cần sử
dụng nó trực tiếp như rt_task_init, nếu bạn sử dụng rtai_lxrt, và rt_kthread_init,
cả rtai_lxrt và rtai_sched, là chỉ những cái cần nhất.
Sau khi gọi lập lịch đối tượng linux của bạn có thể sử dụng của Linux và
RTAI APIs, không có bất kỳ cững ép nào, nhưng bạn sẽ thời gian thực chỉ
trong không gian nhân. Hầu hết bạn phải trong không gian người sư dụng linux
thời gian thực mền được đặt bởi SCHED_FIFO/SCHED_RR trong
rt_task_init_schmod hoặc trong không gian nhân, bằng cách gọi
rtai_set_linux_task_priority để nhận được kết quả tương tự. Chú ý fifo là mặc
định; Round_Robin phải được đặt nếu bạn muốn chạy cái này (xem
rt_set_sched_policy)
Tại điểm này nếu bạn muốn hoạt động thực cúng trong không gian người
dùng bạn phải gọi rtai_make_hard_real_time. Trong không gian người dùng
bạn phải dùng trước như lời gọi nhiệm vụ quan trọng mở rộng thêm vào tiền
phân bố bộ nhớ cần thiết bằng khóa bộ nhớ, xem “man mlockall”, để chuyển
đổi thành static tất cả các nhiệm và heap.
Bạn có thể muốn sử dụng macro rt_grow_and_lock_stack. Cái này là cần
để tránh phá hủy thời gian thực cứng qua trang bộ nhớ ảo động. Trong không
gian nhân là không cần cho nhiệm vụ, nhưng cẩn thận đề phòng bạn phải thay
đổi nhiện vụ nhỏ cái mà không gian nhân có hiệu lực cho kthread của nó, xấp
xỉ 4 hoặc 8 kB do đó làm như nào để bạn có thể cài nó trong linux, nhưng bạn
cần phải làm nhiều tương tự với k/vmalloc, cái này gọi chúng để tất cả các cái
cần thiết trước khi bắt đầu thời gian cứng đại khái, sự kiện nếu không cần bất
kỳ lợi gọi khóa bộ nhớ xa hơn. Báo trước cái có sự khác nhau ở đây với RTAI
nhiệm vụ nhân như để chúng bạn có thể gán nhiệm vụ lớn hơn, để cho phép
trong kích thước bộ nhớ bạn gán tại cài đặt RTAI (mặc định là 2 MB).

Tính toán trong 2MB là toàn bộ vùng heap của RTAI; Nghĩa là nếu
nhiệm vụ dùng tất far nó là không có vùng còn lại để các nhiệm vụ khác thực
hiện đúng đắn. May mắn giá trị này có thể được tăng để phù hợp với ứng dụng
của bạn cần; kích thước vùng heap toàn cụ được xác định qua mục “Other
features” trong giao diện cài đặt :
 Bây giờ bạn trong thời gian thực và để giữ bạn không thể sử dụng bất kỳ
lời gọi hệ thống hoặc vùng kernel phụ vụ như sau:
. gửi bạn trở lại linux tay.
. Thực hiện cái bạn hởi tới linux, có thể lập lịch lại nó.
. Quay lại RTAI thời gian thực khi linux phục vụ bạn. RTAI có thể chịu
nhứng điều đó nhưng nó gợi ý cho bạn sẽ đầy đủ nhận biết nó bằng ghép nhiệm
vụ thời gian thực với thân linux, để điều đó bạn sẽ hỏi sự phục linux bạn cần, vì
vậy nhận biết đầy đủ điều đó bạn sẽ đưa ra thời gian thực cứng cho tới khi thân
thiết phụ vụ bạn. Nếu bạn tìm nó có phiền gồm sử dụng hỗ trợ linux phục vụ
RTAI tạo ra giá trị thông qua: rtai_linux_syscall_server_create; Nếu cái đó vẫn
không chấp nhận được sau đó giữa trộn lẫn Linux và RTAI cho sự kiện nhiệm
vụ cứng nhưng nhận biết là kinh nghiệm được thể hiện sự kinh nghiệm người
dùng được tìm thất đã quá nhiều tin tưởng trong làm việc với nó cách chúng ta
hiểu chúng ta làm cái gì. Quá nhiều tin tưởng sự phục vụ linux là thường ,
không thuật lợi dĩ nhiên, trong trường hợp sai và bạn bị tát, tốt hơn nói bọ sẽ
tát lại kết thúc người chạy, có thể nó là tốt hơn để gọi chúng sự cố của quá
trình. Báo trước RTAI chuyển tiếp như hiệu ứng có thể. Vì vậy khả nawg thời
gian thực cứng nâng cấp trong linux tự nhiên (PREEMPT_RT) như phiền phải
nâng cao một ít. Thời gian thực mức cao hơn có thể được cho phép. Cuối cùng
khi nhiệm vị thoát ra hoặc thời gian thực cứng là không cần thiết bất kỳ gì hơn
một có thể gọi rtai_make_soft_real_timie theo sau:
. rt_task_delete trong không gian người dùng để gỡ bỏ RTAI từ cấu trúc
nhiệm vụ Linux; đây là API có thể cũng bị quên RTAI sẽ tự xóa mọi thứ,
nhưng nó là đề nghị mạnh để xóa một nhiệm vụ trong code của bạn để tránh bất
kỳ hiệu ứng rộng nào.
. clr_rtext trong không gian nhân để làm tương tự cho thread nhân,
nhưng bạn sẽ không cần sử dụng nó trong không gian rt_task_delete là tất cả
cái gì cần trước đó. Phiên bạn mới nhất của RTAI có thể bao gồm điều đó nếu
bạn quên nó.
 Điểm chung ở giản đồ trên là hầu như sử dụng không gian người dùng,
sự tồi tệ để nghi chú ngoại lệ là được tìm thấy trong netrpc.c. Thật sự trong
không gian nhân chuẩn sử dụng trễ để làm việc trong chế độ thời gian thực trực
tiếp và đầy là trong đó sự khác nhau giữ rtai_lxrt và rtai_sched vào trong thực
hiện. Để hiểu rõ hơn, nó có thể gọi lại RTAI đã vào đầu tiền cơ hội thời gian
thực trong không gian người dung và sự sử dụng không gian người dùng / nhân
giành được bằng sử dụng RTAI nhiện vụ nhân nhẹ. Khi cần kết sự hỗ trợ sự
cân đối lập lich trong không gian người dùng/nhân cơ bản trên gần hàng đợi
nhỏ chỉ nhấn mạnh được thay đổi để không gian người dùng chính với vài
không gian nhân. Vì vậy để tránh tạo gánh nặng cho thời gian thực cứng linux,
như đã diễn tả ở trên, Sự hỗ trợ cho việc tạo trực tiếp kthreads linux cứng đã
được tạo ra, bằng cài đặt các chức năng rt_kthread_init và
rt_kthread_init_cpuid, phản chiếu là hàm rt_task_init và rt_task_init_cpuid đã
sử dụng cho làm chủ nhiệm vụ nhân nhẹ RTAI. Tuy nhiên người sử dụng RTAI
hầu như sử dụng các hàm sau, vì vậy để cho phép chung không để ý cái gì ẩn
sau bức màn, nơi có sự cần phải có rt_task_init và rt_task_init_cpuid tạo ra
kthreads linux cứng. Trong sự miêu tả rtai_lxrt phải được sử dụng, vì vậy
kthread_inits và task_inits trở thành giống nhau. Vì vậy người dùng muốn sử
dụng RTAI thread nhân nhẹ hoặc cả chúng và khtread linux cứng hóa có thể sử
dụng rtai_sched, chú ý sự sử dụng kthread_init/task_inits theo như sự cần thiết
của chúng.
Vì vậy hãy giải thoát trễ kế thừa xấu khái niệm sự troi trong liên tiết dài
của truyền thuyết thành thị, đừng nói ĐU, và xóa trạng thái cái mà đã đúng
nhiều năm: Đây chỉ là một cách của lập lịch trong RTAI và nó là góc đầu tiên
RTAI, nó có sự xuất hiện trong hai dạng bởi vì cái gì diễn giải ở trên.
5.2. Thực gian thực thực hiện như thế nào cho đối tượng lập lịch
linux?
Đối tượng lập lịch linux thời gian thực cứng là kthread/threads/xử lý
linux thông thường bằng cách gọi rt_make_hard_real_time nhiệm vụ tự nó tạm
dừng vì đối tượng lập lịch linux khác chuyển vào. Nhanh nhất có thể nhiệm vụ
mới sẽ được chuyển vào, nhiệm vụ chuyển khác RTAI được gọi, khong có sự
kiện thoát vừa gọi Linux lập lịch và nhiệm vụ RTAI được giành lại trong chế
độ đông thời gian thực. Khi nó không có gì để làm, nó sẽ gọi RTAI rt_schedule
và như chức năng lập lịch đối tượng Linux. Cảnh báo trước trong hoạt động
đầy đủ của Linux/RTAI văn cảnh chuyển khác là được tin chắc bằng văn cảnh
thông thường chức năng chuyển khóa có giá trj trong Linux sched.c. Đây là sự
ỏa hóa được tin rằng để đúng gốc, Mặc dù ý tưởng tầm thường, trong môi
trường Linux cái xuất hiện đã sao chép rành rành bởi cái khác. Bằng thủ thuật
các cách khác, đó là quay lại trong linux, đòi hỏi phải cẩn thận. Trong thực tế
cứng hóa đối tượng có thể lập lịch có thể linux giành quyền đầy đủ không có nó
nhận biết cái gì đã xảy ra. Giải quyết vấn đề là không quan trọng như trở thành
suy nghĩ cứng . Vì vậy, cho nhiệm vụ cứng, tự treo và đặt nó trong danh sánh
bộ đệm lặp vòng; Có mỗi cái cho mỗi CPU và đợi để đánh thức bởi lời gọi từ
Linux “wake_up_process” khi không có thời gian thực khác được lập lịch bởi
bộ lập lịch RTAI, vì vậy sự trả lại đầy đủ cho môi trường linux là được bảo
đảm. Cám ơn để hoàn cảnh chuyển khóa tương đồng khi nhiệm vụ được trả về
bởi linux nó tự tìm mềm trở lại. Tuy nhiên nó sẽ không kết thúc lịch của Linux
nhưng của RTAI “rt_schedule” thay vì. Vì vậy RTAI phải được chú ý sự thi
hành kết thúc cùng tìm thấy trong lịch và tất cả ma thuật đen sẽ không gây tổn
hao. Chức năng thực hiện tất cả là: steal_from_linux và give_back_to_linux.
Như các chức năng đã được sử dụng, không co yêu cầu người dùng đòi
hỏi, khi đó thời gian thực cứng đối tượng có thể lập lịch cho phép lời gọi hệ
thống linux. Cho RTAI có được chặng lại lời gọi hệ thống linux và nếu bất kỳ
được hoàn thành trong chế độ thời gian thực cứng đối tượng cứng được đưa
quay lại linux, sau đó phụ thuộc vào cấu trúc lời gọi hệ thống linux là trực tiếp
thực hiện một trong hai (ví dụ, lập lịch RTAI trong) và đối tượng được lấy cắp
từ linux từ sau khi trở lợi từ lời gọi hệ thống (i386) hoặc lời gọi hệ thống được
thực hiện lời gọi hệ thống linux chuẩn đường dẫn, vì vậy, Sự tìm thấy thời gian
thực phần cứng sẽ xảy ra tại lời gọi RTAI tiếp theo (x86_64, hiện tại). Chọn
giữa hai việc là được cài đặt như lựa chọn.
5.3. Các API được cung cấp bởi bộ lập lịch.
Tấc cả các chức năng của bộ lập lịch chung là được thực hiện bởi
base/sched/api.c. Chúng là như sau:
Giái trị trả Chức năng Miêu tả
về
int rt_get_prio (RT_TASK *task) Kiểm tra ưu tiên nhiệm
vụ
int rt_get_inher_prio (RT_TASK *task) Kiểm tra ưu tiên nhiệm
vụ
int rt_change_prio (RT_TASK *task, int Thay đổi ưu tiên nhiệm
priority) vụ
RT_TASK* rt_whoami (void) Lấy con trỏ nhiệm vụ
của nhiệm vụ hiện tại
void rt_task_yield (void) Tiến hành nhiệm vụ hiện
tại
int rt_task_suspend (RT_TASK *task) rt_task_suspend đình chỉ
sự thực hiện của nhiệm
vụi
int rt_task_resume (RT_TASK *task) lấy lại nhiệm vụ.
int rt_get_task_state (RT_TASK *task) Hỏi trạng thái nhiệm vụ
void rt_linux_use_fpu (int use_fpu_flag) đặt chỉ số sử dụng FPU
int rt_task_signal_handler (RT_TASK Tạo nhiệm vụ chạy định
 *task, void (*handler) (void)) kỳ
int rt_task_make_periodic_relative_ns Tại nhiệm vụ chạy định
(RT_TASK *task, RTIME kỳ
start_delay, RTIME period)
int rt_task_wait_period (void) Đợi tới kỳ kế tiếp.
RTIME next_period (void) Lấy thời gian chu kỳ
nhiệm vụ sẽ trả lại sau
khi gọi
rt_task_wait_period.
void rt_busy_sleep (int ns) Trễ/treo thực hiện cho
lặp
int rt_sleep (RTIME delay) Trễ/treo thực hiện cho
lặp
int rt_sleep_until (RTIME time) Trễ/treo thực hiện cho
lặp
int rt_register (unsigned long name, void Đăng ký đối tượng.
*adr, int type, struct task_struct *t)
int rt_drg_on_name (unsigned long Hủy đăng ký một đối
name) tượng băng tên
int rt_drg_on_adr (void *adr) Hủy đăng ký một đối
tượng bằng địa chỉ.
unsigned rt_get_name (void *adr) Lấy một đối tượng tên
long bằng địa chỉ.
void * rt_get_adr (unsigned long name) Lấy một đối tượng địa
chỉ băng tên
Bằng sử dụng chusng một chương trình có thể truy nhập lập lịch trả giá kiểm
định băng RTAI.
5.3.1. Miêu tả hàm
int rt_get_prio (RT_TASK *task)
Với hàm này một chương trình có thể kiểm tra ưu tiên thực hiện của một nhiệm
vụ, Nó trả về ưu tiên cơ bản của nhiệm vụ.
Nó là rất quan trọng để nhớ nhiệm vụ có ưu tiêncơ bản tự nhiên không, gán tại
lúc sinh ra hoặc bởi hàm rt_change_prio, và thực hiện, kết thừa, ưu tiên. Chúng
có thể khác nhau bởi vì ưu tiên kế thừa/ ưu tiên động tối đa, nhìn cài đặt.
Các thông số:
task là nhiệm vụ
Trả về:
rt_get_prio trả về ưu tiên của nhiệm vụ.
Đây là hàm và 2 hàm tiếp theo với ưu tiên của nhiệm vụ. Giá trị ưu tiên
được định nghĩa trong base\include\rtai_sched.h như sau:
#define RT_SCHED_HIGHEST_PRIORITY 0
#define RT_SCHED_LOWEST_PRIORITY 0x3fffFfff
#define RT_SCHED_LINUX_PRIORITY 0x7fffFfff
Chú ý các nhiệm vụ với mức ưu tiên cao hơn (giá trị thấp hơn)
là được thực hiện trước và không thể ngắt bởi nhiệm vụ có mức
ưu tiên thấp hơn (giá trị lớn hơn).

int rt_get_inher_prio (RT_TASK *task)

Hàm này kiểm tra thực hiện ưu tiên của nhiệm vụ. Nó trả về
mức ưu tiên nhiệm vụ nhiệm vụ kế thừa từ nhiệm vụ khác, một
trong hai khóa nguồn hoặc đợi cho tin nhắn tới nhiệm vụ.
Thông số:
task là nhiệm vụ.
Trả về :
rt_get_inher_prio trả về ưu tiên nhiệm vụ.
Hàm cũng trả tất cả các ưu tiên trong một lời gọi là int rt_get_priorities
(RT_TASK *task, int * priority, int *base_priority).
int rt_change_prio (RT_TASK *task, int priority)
Với hàm này nó có thể thay đổi mức ưu tiên cơ bản của nhiệm vụ nhiệm
vụ đưa ra. Gọi lại nhiệm vụ có mức ưu tiên cơ bản tự nhiên, gán ở thời điểm
sinh ra và thực hiện, kết thừ, ưu tiên. Chúng có thể khác nhau bởi vì sự kế thừa.
Các thông số:
task nhiệm vụ
priority là mức ưu tiên mới, phạm vi của nó 0 < priority <
RT_SCHED_LOWEST_PRIORITY
Trả về:
rt_change_prio trả về ưu tiên cơ bản của nhiệm vụ trước khi có
thay đổi.
Chú ý:
Sự thay đổi ưu tiên của nhiệm vụ từ sự khác nhau thực hiện nhân
bản nếu nhiệm vụ đang nhận được khóa trong nguồn. Nghĩa là sự thay đổi phải
được thực hiện đúng không gian và trong đúng thời điểm giành được hiệu lớn
nhất.

RT_TASK* rt_whoami (void)

Các hàm này có thể sử dụng để nhận con trở của nhiệm vụ hiện tại. Giá
trị trả về là cấu trúc của nhiệm vụ đang được gọi. Các trúc được định nghĩa
trong file include base\include\rtai_sched.h file và chứa tất cả các dữ liệu liên
quan tới nhiệm vụ đơn.
Trả về:
 Con trỏ tới nhiệm vụ hiện tại.
hàm này được dùng tiều biểu như
rt_task_delete (rt_whoami())
hoặc
task = rt_whoami(); trong đó nhiệm vụ được định nghĩa là
RT_TASK *task.
Sự định nghĩa của cấu trúc RT_TASK được như sau và như bạn có thể
thấy nó bao gồm tất cả các thông tin liên quan để nhiệm vụ có thể điều khiển
đúng bởi RTAI.
struct rt_task_struct *rnext;
/* Appended for calls from LINUX. */
long *fun_args;
long *bstack;
struct task_struct *lnxtsk;
long long retval;
char *msg_buf[2];
long max_msg_size[2];
char task_name[16];
void *system_data_ptr;
struct rt_task_struct *nextp;
struct rt_task_struct *prevp;
/* Added to support user specific trap handlers. */
RT_TRAP_HANDLER task_trap_handler[HAL_NR_FAULTS];
/* Added from rtai-22. */
long unblocked;
void *rt_signals;
volatile unsigned long pstate;
unsigned long usp_flags;
unsigned long usp_flags_mask;
unsigned long force_soft;
volatile int is_hard;
void *trap_handler_data;
struct rt_task_struct *linux_syscall_server;
/* For use by watchdog. */
int resync_frame;
/* For use by exit handler functions. */
XHDL *ExitHook;
RTIME exectime[2];
struct mcb_t mcb;
/* Real time heaps. */
struct rt_heap_t heap[2];
volatile int scheduler;
#ifdef CONFIG_RTAI_LONG_TIMED_LIST
rb_root_t rbr;
rb_node_t rbn;
#endif
} RT_TASK __attribute__ ((__aligned__ (L1_CACHE_BYTES)));
void rt_task_yield (void)
Hàm này tiến hành nhiệm vụ hiện tại. Đó là, nó dừng nhiệm hiện tại và
đặt nó vào phía cuối của danh sanh vủa các nhiệm vụ sẵn sành có cùng mức ưu
tiên. Bộ lập lịch tạo ra nhiệm vụ kế tiếp sẵn sàng của cùng mức ưu tiền tích
cực.
Gọi lại bộ lập lịch RTAI cho phép chỉ những nhiệm vụ có mức ưu tiên
cao hơn giành quyền thực hiện nhiệm vụ có mức ưu tiên thaaso hơn. Vì vậy
nhiệm vụ cùng mức ưu tiên không thể giành quyền của nhiệm vụ khác và
rt_task_yield() có thể sử dụng nếu người sử dụng cần thời gian tập theer trượt
giữa các nhiệm vụ cùng mức ưu tiên.
Sự thực hiện quy định cùa mối quan hệ là phụ thuộc hoàn toàn vào người sử
dụng. Hãy tin rằng thời gian trượt là quá nhiều quá cao hơn cho ứng dụng thời
gian thực khắt khe lớn nhất, vì vậy nó là được cho phép. Ngoài ra đặt vào trong
sự tính toán quanh quy định, đó là có ý định sự dụng chỉ khi nếu bạn có vài
nhiệm vụ, đang chạy với cùng mức ưu tiên và với không có sự giải phóng CPU
(no rt_task_yield). Trong trường hợp luật RR sẽ được quan tâm để cân bằng
chúng.

int rt_task_suspend (RT_TASK *task)

rt_task_suspend đình chỉ sự thực hiện của nhiệm vụ.,

Nhiệm vụ sẽ không được chạu cho tới khi có lời gọi rt_task_resume()
hoặc rt_task_make_periodic() là được tạo ra. Không có tính toán được tạo ra
cho nhiều đình trỉ. ví dụ nhiễu đình chỉ nhiệm vụ được tạo ra sẵn sàng sớm nhất
như rt_task_resumed, vì vậy ngay lập tức rành lại sự thự hiện của nó nếu nó là
mức ưu tiên cao nhất.
Các thông số:
task trỏ tới cấu trục nhiệm vụ,
Trả về:
nhiệm vụ được đình chỉ sâu, sự kết thúc không bình thường được
miêu tả ở dưới:
. –EINVAL: nhiệm vụ không chuyển đến nhiệm vụ có hiệu lực
A NULL con trỏ chỉ thị nhiệm vụ đang được gọi
RTE_UNBLKD: nhiệm vị đã được mở khóa trong khi đình chỉ;
Tương tự chức năng có thể dùng 3 API sau:
 1. int rt_task_suspend_if (RT_TASK *task)
2. int rt_task_suspend_until (RT_TASK *task, RTIME time)
3. int rt_task_suspend_timed (RT_TASK *task, RTIME delay)
Các hàm đình chỉ có thể sử dụng như các công cụ đồng bộ, bằng cách
tương tự như kỹ thuật semaphore nhưng được dùng cho nhiệm vụ. Đó làm nó
có thể chỉ được sử dụng bằng csc nhiệm vụ tự nó, trong khi semaphone có thể
sử dụng để tập trung đợi các nhiệm vụ khác. Ngoài ra, nhiệm vụ có thể cũng
được đình chỉ bởi các nhiệm vụ khác (trong khi semaphore thì không theerO;
trong trường hợp này, các thực hiện là tương tự nhưng có phương pháp đếm là
đảm bảo an toàn đồng bộ.

int rt_task_resume (RT_TASK *task)

Chức năng này lấy lại thực hiện nhiệm vụ của nhiệm vụ đã được đình
chỉ bởi rt_task_suspend (), hoặc được tạo ra nhiệm vụ mới đã sẵn sàng chạy.
Từ khi có bộ đếm cố định cho nhiều đình chỉ, bạn cần gọi rt_task_resume nhiều
lần như nó được được đình chỉ để lấy lại nó.
các thông số:
task trỏ tói các trúc nhiệm vụ.
trả về:
0 thành công. giá trị âm lỗi được miêu tả ở dưới.
EINVAL: nhiệm vụ không có giá trị.
int rt_get_task_state (RT_TASK *task)

đây là API hỏi trạng thái hoạt động của nhiệm vụ thời gian thực.
Các thông số:
taskL là con trỏ trỏ tới cấu trúc nhiệm vụ
Giá trị trả về:
Trạng thái nhiệm vụ là đóng khung bởi đảo bit OR hoặc một hoặc nhiều
hờn theo các cờ:
RT_SCHED_READY nhiệm vụ đã sẵn sàng để chậy (nhiệm đã mở
khóa). Chú ý trên máy bộ đơn sử lý nhiệm vụ đang chạy hiện tại là vừa có
trạng thái sẵn sàng, trong khi đa sử lý có thể (sẵng sàng hoặc chạy) xem ở dưới.
RT_SCHED_SUSPENDED nhiệm vụ được khóa đang đợi để rành lại
RT_SCHED_DELAYED nhiệm vụ được khóa đang đợi cho thời điểm
chạy kết
tiếp hoặc hết thời gian trờ
RT_SCHED_SEMAPHORE nhiệm vụ được khóa bởi semaphore, đang
đợi cho tín hiệu semaphore.
RT_SCHED_SEND nhiệm vụ được khóa đang gởi tin nhắn, bộ
nhận không ở trọng thái nhận.
 RT_SCHED_RECEIVE nhiệm vụ được khóa đang đợi cho tín hiệu vào,
gửi hoặc rpcs.
RT_SCHED_RPC nhiệm vụ được khóa trên thủ tục gọi ngoài, bộ nhận
đã không ở trạng thái nhận.
RT_SCHED_RETURN nhiệm vụ được khóa đợi cho trả lại từ thủ tục
gọi ngoài; bộ nhận có RPC nhưng chưa trả lời.
RT_SCHED_RUNNING nhiệm vụ đang chạy, chỉ sử dụng cho hàng đợi
SMP.
Chú ý trạng thái nhiệm vụ trả về là các thông tin xấp xỉ. Bộ thời gian và
các ngắt phần cứng khác có thể gây thay đổi trong trạng thái của nhiệm vụ
được hỏi lời gọi có thể ước định giá trị trả về. Nghĩa là lời gọi có thể ngưng
ngắt nếu nó muốn trả lời thông tin về các một nhiệm vụ khác. Nó cũng quan
trọng để hiểu rt_get_task_state không thực hiện bất kỳ kiểm tra nào trên con trỏ
nhiệm vụ.
Để phù hợp sử dụng rt_get_task_state_functions là nội dung biên dịch
trả về giá trị có thể là sự kết hợp của các cờ trên như ví trị sau:

for (i = 0; i < NTASKS; i++) {

rt_task_resume(&thread[i]);
// to be sure they are all wait synchronized
while(!(rt_get_task_state(&thread[i]) &
RT_SCHED_SEMAPHORE));
}

void rt_linux_use_fpu (int use_fpu_flag)

Hàm này đặt các chỉ thị của sự sử dụng FPU và báo cho bộ lập lịch biết
toán tử số học dấu phảy động sẽ được sử dụng bởi sử lý linux trước. ví dụ nhân
linux tự nó và bất kỳ sự sử lý nào của nó
Các thông số:
use_fpu_flag nếu đây là thông số có giá trị khác không, đơn vị dấu phảy
động chuyển ngữ cảnh khi nhiệm vụ hoặc nhân trở lên tích cực
Chú ý cho phép sử dụng FPU tạo ra nhiệm vụ chuyển khóa lâu hơn.,
không đáng kể, trong tất cả có CPU 32bits nhưng với 386s và cũ hơn 486s.
Những cờ này có thể được đặt bởi rt_task_init kkhi nhiệm vụ thời gian thực
được tạo ra. Với UP và MUP bộ lập lịch quan tâm lấy đi tránh ít sử dụng
saves/restores của FPU môi trường, Với SMP, các nhiệm vụ có thể được di
chuyển từ CPU tới CPU vì saves/restores cho các nhiệm vụ sử dụng FPU là
luôn thực hiện. Chú ý mặc định Linux cờ này đã được tạo. Dù thế nào, đâu là
phiên bản mới nhất điều khiện này được luôn được bật, nghĩa là FPU là sẵn
sàng được sử dụng từ khi bắt đầu mọi thứ.
 int rt_task_use_fpu (RT_TASK *task, int use_fpu_flag)
rt_task_use_fpu báo cho bộ lập lịch toán tử số học dấu phảy động sẽ
được sử dụng bởi nhiệm vụ thời gian thực.
Các thông số:
task đây là con trỏ trỏ tới nhiệm vụ thời gain thực.
use_fpu_flag nếu thông số này có giá trị khác không, đơn vị dấu phảy
động cũng chuyển khóa khi nhiệm vụ hoặc nhân được tích cực.
Trả về:
. 0 thành công, giá trị âm là lỗi được miêu tả ở dưới.
. –EINVAL: nhiệm không có giá trị,
Xem ở : rt_linux_use_fpu() miêu tả làm thế nào để sử dujg FPU ảnh hưởng tới
hiệu năng chuyển khóa.

Chú ý gọi hàm này từ không gian người dùng là không thực sự có ích
như nó chỉ tránh bẫy trong lần đầu sử dụng. Trong thực tế, sau TRAP đầu tiên,
FPU sẽ sẵn sàng. Bất kể như thế nào, lời gọi hàm này được tăng hiệu năng của
hệ thống bởi giảm các trễ do bẫy gây ra. như giải pháp thay thế, trong không
gian người dùng, bạn có thể sử dụng FPU trong chế độ mền bằng tạo ra bất kỳ
hoạt động nào và nó sẽ sẵn sàng khi chuyển sang chế độ cứng.
Trong khôn gian nhân, sự thỏa luận ở trên là không giá trị và, nếu không
nhiệm vụ sẽ không được tạo ra để sử dụng FPU, đây là API phải được gọi để
tránh các vấn đề.
int rt_task_signal_handler (RT_TASK *task, void (*)(void) handler)

Các hàm này đặt tín hiệu điều khiển của nhiệm vụ bằng cài đặt, thay đổi,
tín hiệu hàm của nhiệm vụ thời gian thực.
Các thông số:
task: là con trỏ trỏ tới nhiệm vụ thời gian thực.
handler là con trỏ toàn bộ của hàm tín hiệu.
Tín hiệu hàm điều khiển có thể đặt khi nhiệm vụ được tạo ra mới với
rt_task_init(). Điều khiển tín hiệu là hàm được gọi trong đó môi trường nhiệm
vụ và ngắt được bỏ qua, trong khi nhiệm vụ trở lên nhiệm vụ đang chạy hiệm
tại sau khi chuyển khóa cảnh, loại trừ tại thời điểm đầu lập lịch. Nó cho phép
bạn thực hiện bất kể quy định quản lý tín hiệu bận nghĩa có ích, và nhiều các
khác là tốt.
Trả về:
0 thành công. Giá trị âm lỗi được miêu tả ở dưới.
- EINVAL: nhiệm vụ không có giá trị.
Chú ý:
API này có thể sử dụng trong không gian nhân.
int rt_task_make_periodic_relative_ns (RT_TASK *task, RTIME start_delay,
RTIME period)
rt_task_make_periodic_relative_ns tạo ra nhiệm vụ chạy định kỳ; nó
đánh dấu nhiệm vụ truwowsci được tạo với rt_task_init(), phù hợp sự chạy ưu
tiên, với thời điểm khi rt_task_wait_period() được gọi.

Thời gian thực hiện đầu tiên được định nghĩa qua start_delay các quan
hệ với thời gian hiện tại và nó được do la nano giây.
Các tham số:
task là con trỏ trỏ tới nhiệm vụ bạn muốn để tạo ra chu kỳ.
start_delay là thời gian, để đợi trước khi nhiệm vụ bắt đầu, trong
nano giây. thời điểm đáp ứng với nhiệm vụ trong nano giây.

giá trị trả về:

0 thành công. Giá trị âm là lỗi được miêu tả ở dưới.
-EINVAL: nhiệm vụ không có giá trị.
A NULL con trỏ thể hiện nhiệm vụ đang được gọi.

Nó là rất quan trọng để hiểu giới hạn clock_ticks (nhịp đồng hồ) phụ
thuộc vào chế độ trong chạy bộ thời gian cứng. Vì vậy nếu bộ thời gian cứng
đã đặt chu kỳ nhịp đồng hồ sẽ là thời gian cuối đặt trong start_rt_timer, trong
khi nếu ở chế độ oneshop, nhịp đồng hồ sẽ đảo tần số chạy của bộ thời gian
cứng trong sử dụng và bất kể thời gian nào sử dụng trong lời gọi start_rt_timer.

Theo mã nguồn, được lấy trong kho trưng bày (kern/i385/scb), sử dụng
api này. Trong chế độ này, Nó được thiết kế để chạy trong chế độ nhân, bạn sẽ
nhìm thấy vài API quan trọng chưa được miêu tả, nhưng nó là quan trọng để
bắt đầu xem chúng, bởi vì chúng đã đề cập trong lệnh và chúng là bắt buộc
được cài đặt nhiệm vụ thời gian thực. Chú ý đọc kiểm chứng theo mã nguồn
API màu đỏ được miêu tả trong chương này, trong khi mầu xanh là chú thích
đơn giản.
Example 1 speaker.c:
#include <linux/kernel.h>
#include <linux/module.h>
#include <asm/io.h>
#include <rtai_nam2num.h>
#include <rtai_sched.h>
#include <rtai_scb.h>
#include "pcsp_tables.h"
MODULE_LICENSE("GPL");
//#define CONFIG_X86_64
#define SCBSUPRT USE_GFP_ATOMIC
#define SCBSIZ 2000
#define TICK_PERIOD 25000 /* 40 khz */
#define DIVISOR 5
#define STACK_SIZE 4000
/*You can make this bigger, but then you start to get
*clipping, which sounds bad. 29 is good.
*/
#define VOLUME 30
static RT_TASK thread;
static int cpu_used[NR_RT_CPUS];
static unsigned char vl_tab[256];
static int port61;
static void *scb;
static volatile int end;
#define PORT_ADR 0x61
static int filter(int x)
{
static int oldx;
int ret;
if (x & 0x80) {
x = 382 – x;
}
ret = x > oldx;
oldx = x;
return ret;
}
static void intr_handler(long t)
{
char data, temp;
int go = 0;
int divisor = DIVISOR;
while (!end) {
if (!(--divisor)) {
divisor = DIVISOR;
cpu_used[hard_cpu_id()]++;
go = !rt_scb_get(scb, &data, 1);
}
else {
go = 0;
} if (
go) {
#ifdef CONFIG_X86_64
data = filter(data);
temp = inb(PORT_ADR);
temp &= 0xfd;
temp |= (data & 1) << 1;
outb(temp, PORT_ADR);
#else
outb(port61, 0x61);
outb(port61^1, 0x61);
outb(vl_tab[((unsigned int)data)&0xff], 0x42);
#endif
}
rt_task_wait_period();
}
}
int init_module(void)
{
int i;
outb_p(0x92, 0x43); /* binary, mode1, LSB only, ch 2 */
for (i = 0; i < 256; vl_tab[i] = 1 + ((VOLUME*ulaw[i]) >> 8), i+
+);
port61 = inb(0x61) | 0x3;
scb = rt_scb_init(nam2num("SCB"), SCBSIZ, SCBSUPRT);
rt_task_init(&thread, intr_handler, 0, STACK_SIZE, 0, 0,
0);
rt_set_oneshot_mode();
start_rt_timer(0);
rt_task_make_periodic_relative_ns(&thread, 10000000,
TICK_PERIOD);
return 0;
}
void cleanup_module(void)
{
int cpuid;
end = 1;
stop_rt_timer();
rt_task_delete(&thread);
rt_scb_delete(nam2num("SCB"));
printk("\n\nCPU USE SUMMARY\n");
for (cpuid = 0; cpuid < NR_RT_CPUS; cpuid++) {
printk("# %d -> %d\n", cpuid, cpu_used[cpuid]);
}p
rintk("END OF CPU USE SUMMARY\n\n");
}

int rt_task_make_periodic (RT_TASK *task, RTIME start_time,

RTIME period)
đây là hàm tương tự cái trước chỉ khác start_time và
period là nhịp đồng hồ trong nano giây. Nó tạo ra nhiệm vụ
chạy chu kỳ bởi đánh dấu nhiệm vụ, được tạo bởi rt_task_init(),
phù hợp với thực hiện ưu tiên, với period chu kỳ, khi
rt_task_wait_period () được gọi.
Thời gian thực hiện đâu tiên được định nghĩa qua
start_time là giá trị tuyệt đói đo được trong nhịp đồng hồ.
các than số:
task là con trỏ trỏ tới nhiệm vụ bạn muốn tại chu kỳ.
start_time là thời gian tuyệt đói đợi trước khi nhiệm
vụ bắt đầu chạy trong nhịp đồng hồ.
period tương ứng với chu kỳ của nhiệm vụ trong nhịp
đồng hồ.
Giá trị trả về:
0 thành công. Giá trị âm lỗi được miêu tả ở dưới.
-EINVAL: nhiệm vụ không có giá trị.
A NULL con trỏ chỉ thị nhiệm vụ đang gọi.
Cũng có thể xem: rt_task_make_periodic_relative_ns().
Gọi lại giới hạn nhịp đồng hồ phụ thuộc vào chế độ trong thực
hiện thời gian cứng. Vì nếu thời gian cứng đã được đặt như chu
kỳ nhịp đồng hồ sẽ là thời gian cuối cùng đặt trong
start_rt_timer, trong khi nếu chế độ oneshot được sử dụng
nhịp đồng hồ là cái cuối cùng đảo của tần số chạy của bộ thời
gian trong sủ dụng và không kể bất luận thời gian nào dùng
trong lời gọi tới start_rt_timer.

int rt_task_wait_period (void)

Đây là hàm đợi cho đến khi chu kỳ kết tiếp đang treo thực
hiện của nhiệm vụ thời gian thực hiện tại đang chạy, cho tới khi
đạt tới chu kỳ kết tiếp. Nhiệm vụ phải đánh dấu trước cho thực
hiện chu kỳ bởi lời gọi rt_task_make_periodic() hoặc
rt_task_make_periodic_relative_ns().
Trả về:
 0 nếu chu kỳ là cuối cùng xả ra, kết thúc không bình
thường trả về được miêu tả ở dưới:
RTE_UNBLKD: nhiệm vụ được mở khóa trong khi ngủ.
RTE_TMROVRN: trả về ngay lập tức lấy được bởi vì chu kỳ
kết tiếp đã hết.

Chú ý nhiệm vụ bị treo chỉ tạm thời, nghĩa là nó đưa điều

khiển đơn giản cho tới chu kỳ kết tiếp.
RTIME next_period (void)

Nó lấy thời gian chu kỳ nhiệm vụ sẽ được giành về sau khi

gọi rt_task_wait_period, Hàm này trả về thời gian khi lời gọi
nhiệm vụ sẽ chạy kết tiếp. Được liên hợp thích hợp vói
rt_get_time_function() nó có thể được sử dụng để kiểm tra
phân số của chu kỳ sử dụng hoặc bất kỳ sự tràn chù kỳ nào.
Trả về:
Thời gian chu kỳ kết tiếp trong đơn vị đếm trong.

void rt_busy_sleep (int ns)

Đây là hàm trễ/treo thực hiện của sự gọi nhiệm vụ cho
các chu kỳ thiết lập của thời gian không có sự đưa lại sự điều
khiển tới bộ lập lịch. Nghĩa là rt_busy_sleep đốt chu kỳ CPU
trong lặp đợi bận vì vậy nó có thể sử dụng chỉ để đồng bộ rất
ngắn trễ. Trong máy không có đồng hồ nó có thể chỉ cho rất
nhiều micro giây không rõ rành bận ngủ bởi vì cần đọc bộ timer
8254.
Tham số:
ns là số nano giây để đợi.

Hành động ngủ có thể thực hiện bằng sử dụng hai hàm
khác nhau :
. rt_sleep (RTIME delay) bị treo thực hiện của lời gọi nhiệm
vụ cho thời gian trễ trong đơn vị đếm trong,. Trong khi thời
gian này CPU là được sử dụng bởi các nhiệm vụ khác. Hàm này
trả về 0 nếu trễ hết hoặc RTE_UNBLKD nếu nhiệm vụ được mở
khóa trong khi ngủ hoặc RTE_TMROVRN nếu một trả về tức thì
được lấy bởi vì trễ là quá ngắn để thực hiện.
rt_sleep_until (RTIME time) là tương tự rt_sleep() nhưng tham số thời
gian là thời gian tuyệt đối cho tới khi nhiệm vụ có bị đình chỉ. Nếu đưa thời
gian đã qua để gọi sẽ không hiệu lực. Nó trả về 0 nếu ngủ hết được thực hiện
hoặc RTE_UBBLKD nếu nhiệm vụ là mở khóa trong khi ngủ hoặc
RTE_TMROVRN nếu một trả về là được lấy bởi vì thời gian hạn trót đã hết.
Chú ý nhiệm vụ chu kỳ cao hơn hoặc ngắt điều khiển có thể chạy trước
nhiệm vụ ngủ, vì vậy thời gian thực hiện tiêu tốn trong các hàm này có thể dài
hơn lý thuyết.

int rt_register (unsigned long name, void *adr, int type, struct task_struct
*t)
Hàm này được sử dụng để đăng ký một định danh đối tượng với tên
được trỏ bởi địa chỉ,
Trả về:
Số dương thành công, số 0 lỗi.

Một ví dụ làm thế nào để sử dụng hàm này trong chỗ chứa trưng bày
dưới /user/i386/resumefrominter. theo mã nguồn thể hiện có hai cách để đánh
thức xử lý thời gian thực cứng trong không gian người dùng trực tiếp từ ngắt
điều khiển. Xử lý tự nó có thể hoạt động, từng phần, hoặc hư hỏng, một điều
khiển ngắt nhưng không làm lộn xộn với chia đôi dưới, nó là tốt hơn, trực tiếp
hơn, hiệu quả và thời gian thực đúng hơn. Nó là cơ bản sử dụng treo hoặc giành
lại hoặc semaphore đợi/ tín hiệu/ Trong ví dụng này, bạn cũng có thể điều
khiển chu kỳ, trong khoảng thời gian và phương pháp đánh thức qua macro
trong period.h. Như đã miêu tả trước khi API được miêu tả trong chương này
được đánh dấu là đỏ.
Example 2 rt_handler.c:
#include <linux/module.h>
#include <asm/io.h>
#include <rtai_registry.h>
#include <rtai_mbx.h>
#include "period.h"
static MBX mbx;
static SEM sem;
static char wakeup;
static void rt_timer_tick(void)
{
RT_TASK *task;
rt_times.tick_time = rt_times.intr_time;
rt_times.intr_time = rt_times.tick_time + rt_times.periodic_tick;
rt_set_timer_delay(0);
if (rt_times.tick_time >= rt_times.linux_time) {
rt_times.linux_time += rt_times.linux_tick;
rt_pend_linux_irq(TIMER_8254_IRQ);
}
rt_mbx_receive_if(&mbx, &wakeup, 1);
if (wakeup) {
if ((task = rt_get_adr(nam2num("PRCTSK")))) {
if (wakeup==1) rt_sem_signal(&sem);
else rt_task_resume(task);
}
}
}
int init_module(void)
{
rt_mbx_init(&mbx, 1);
rt_register(nam2num("RESMBX"), &mbx, IS_MBX, 0);
rt_sem_init(&sem, 0);
rt_register(nam2num("RESEM"), &sem, IS_SEM, 0);
rt_request_timer(rt_timer_tick, imuldiv(PERIOD, FREQ_8254,
1000000000), 0);
return 0;
}
void cleanup_module(void)
{
rt_free_timer();
rt_mbx_delete(&mbx);
rt_sem_delete(&sem);
}

int rt_drg_on_name (unsigned long name)

Hàm này được hủy đăng ký định danh đối tượng bằng tên.
Trả về:
Số dương thành công, 0 lỗi.

int rt_drg_on_adr(void *adr)

Hàm này hủy đăng ký đối tượng bởi địa chỉ của nó.
Trả về:
Số dượng nếu thành công, 0 lỗi.

void * rt_get_adr (unsigned long name)

nó lấy địa chỉ đối tượng bằng tên.
trả về:
địa chỉ liên kết với tên thành công, 0 lỗi.
unsigned long rt_get_name (void * adr)
Hàm này lấy tền đối tượng bằng địa chỉ của nó.
Trả về:
Định danh được trỏ bới địa chỉ adr nếu thành công, 0 lỗi.

Chương 6, Sự tạo nhiệm vụ và bộ thời gian.

 Các chương trước vài API như rt_task_init đã được giới thiệu, chúng
miêu tả cơ bản bắt đầu để tạo nhiệm vụ thời gian thực. Trong đoạn văn bạn sẽ
học làm thế nào để tạo và khởi tạo nhiệm vụ thời gian thực, cả trong chế độ
nhân và người sử dụng, và làm thế nào để đối xử với bộ thời gian. Mới hơn là
đặc điểm quan trọng khác để điều khiển thời gian nhiệm vụ mặc định
, và hiểu chúng đúng là rất quan trọng để tránh các lỗi xa và thực hiện sai cho
dự án của bạn.
6.1. RTAI tạo thời gian thực nhiệm vụ.
Chúng ta đã giới thiệu khả nangrwm trả giá dùng RTAI, để điều khiển
hai loại nhiệm vụ thời gian thực khác nhau; một viết cho chế độ nhân và một
phát triển cho chế độ người dùng. Nó là chung để tin rằng hai chế độ là khác
nhau về căn bản và chúng thuộc về thế giói đối lập, nhưng đây thì không đúng,
nhất là từ con trỏ lập trình quang cảnh. Khác nhau thực sự xếp đặt trong bản
thân RTAI và nó không phải vài cái sẽ ảnh hưởng thới cách lập trình, hoặc ít
nhất, nếu nó xảy ra, chỉ trong giản vẻ bề ngoài, Vì vậy bạn có thể giả định sự
khác nhau, nếu giới hạn để tại nhiệm vụ, là chỉ trong Makefile và trong vời kỹ
thuật kiểu lập trình khác với sự khác nhau module nhân từ chuẩn nhiệm vụ,
trong khi RTAI là hầu hết tương đương.
6.1.1. Chế độ nhân nhiệm vụ thời gian thực.
Nhiệm vụ thời gian thực chạy như modlue nhân được tạo ra bởi hai vùng
chính của mã, là tương tự cho tất cả các nhân, sự kiện chuẩn một trong cây
nguồn GNU/Linux, không có gì để làm với thời gian thực và với RTAI, vì vậy
bất kỳ module nhân được tạo bởi con trỏ toàn cục được gọi bởi init_module ()
và bởi cleanup_module () hàm. Đây, chúng ta sẽ không đi sâu hai hàm trên,
như tìm kiếm trên internet sẽ cho bạn rất nhiêu thông tin, nhưng để có lợi cho
người đọc miêu tả nhỏ sẽ có ích.
hàm init_module được gọi bởi bất kỳ thời gian module được trền vào
nhân chạy, bởi sử dụng ứng dụng insmod; nó chính là mục đính để chuẩn bị
module để thực hiện, và nó đặt tư tưởng để định nghĩa tất các hàm tiền định, để
chỉ định nguồn và để nhiệm vụ thời gian thực bắt đầu, bằng cách sử dụng API
chỉ định của RTAI. Nó là bản sao để hàm cleanup_module() được gọi và chạy
trong khi module được rời đi từ nhân (xem tiện ích rmmod).
Example 1 rtai_kernel_mode_task.c:
#include <linux/module.h>
#include <asm/io.h>
MODULE_LICENSE(“GPL”);
int init_module(void)
{
printk(“Init module function starting point\n”);
rerturn 0;
}
void cleanup_module(void)
{
printk(“Cleanup module function starting point\n”);
}

Để biên dịch trên, đơn giản, file test bạn sẽ cần make file, cách tốt nhất
để bắt đầu là dẫn xuất nó từ một make file khác trong kho trưng bày. Đơn giản
tóm lấy một từ cây nhân và sử nó, sau đó chạy lệnh make.
Đây là khía cạnh không kỹ thuật quang trọng để nhớ. Nếu bạn dự định
với một ứng dụng trong không gian nhân; giấy phép, Nhân giao tiếp là xam hơn
nưa. ngay lại ngày, module non-GPL bị vi phạm giấy phép nhân, vì vậy nếu
bạn cân nhắc bán dự án của bạn có thể biết điều đó; trong trường hợp này, bắt
đầu cân nhắc đẻ phát triển nó như chế độ người dùng RTAI thay vì dứng dụng
(với LGPL).
6.1.2. Nhiệm vụ thời gian thực chế độ người dùng.
Nhiệm vụ thời gian thực chế độ người dùng sẽ thể hiện đơn giản hơn để
tạo, với chế độ nhân. Nó chỉ đơn giản là nhiệm vụ GNU/Linux với hàm main();
nhưng bởi sự gọi vài API RTAI chỉ định nó sẽ trở vào chạy nhiệm vụ thời gian
thực trong chế độ người dùng. Như đã giới thiệu trước đó, quyết định gần
(nhân/ người dùng) là lựa chọn mang tính cá nhân; Nó thực sự đúng 2 chiến
lược thể hiện âm dương với tổng kết như sau:
. Chế độ nhân nhiệm vụ có thể cần thiết để giảm trễ tới nhỏ nhất và có
thể chạy ở tần số cao hơn.
. Chế độ người dùng sẽ cho phép tích hợp dễ hơn với thế giới
GNU/Linux như bạn có thể truy nhập nhiều nguồn hơn.
. Cả hai cho phép truy nhập cứng, nhưng nếu bạn muốn điều khiển và
phần cứng với ngắt chế độ nhân được là không biết làm sao để chỉ thị. Sự kiện
nếu RTAI có hỗ trợ cho ISR người dùng.
Cuối cùng, nhưng không ít nhất, cân nhắc xem nhiệm vụ thời gian thực
chế độ người dùng; kiểm định đơn RTAI (ghi chú trước, cho người dùng khinh
nghiệm LXRT hoặc NEWLXRT) là phương pháp được ưu thích hơn để tạo
nhiệm vụ thời gian thực bởi giao tiếp. Cá nhân tôi thích ý tưởng đó, nếu không
có lý do kỹ thuật tốt, luôn dùng thời gian thực không gian người dùng. Đã nói,
trong khi đọc chương này, nó sẽ dễ để chú thích bao nhiêu thức hai trạng thái
chung và chuyển hướng từ một chế độ tới chế độ khác là không nhiệm vụ phức
tạp để dùng. Nó sẽ yêu cầu vài điều chỉnh và vài dòng mã nhỏ. Đối với
Makefile, như cho module nhân, tốt nhất, dễ hơn và nhanh hơn sự đến gần một
cái từ kho trưng bày (trong thư mục người dùng) và sử nó đúng với bạn cần.
6.1.2. Làm thế nào để cho phép kiểm định thời gian thực
Cái gì bạn chọn (chế độ nhân hay người dùng) bây giời thời gian để giới
thiệu cách cho phép nhiệm vụ của bạn truy nhập kiểm định thời gian thực
RTAI. Làm điều đó nó là để tạo TASK chỉ định với hàm chỉ định rt_task_init.
Nhiệm vụ được tạo ra là kiểu RT_TASK, Được định nghĩa giải thích ở trương
trước.
Đối với chế độ nhân:

int rt_task_init (RT_TASK *task, void (*rt_thread)(long), long data, int

stack_size, int priority, int uses_fpu, void (*signal)(void))

int rt_task_cpuid (RT_TASK *task, void (*rt_thread)(long), long data,

int stack_size, int priority, int uses_fpu, void (*signal)(void), unsigned
int_cpuid)

Cả hai tạo ra nhiệm vụ thời gian thực trong không gian nhân.
Các thông số:
*task là con trỏ để một cấu trúc RT_TASK kiểu có không gian phải
được cấp bởi ứng dụng, và phải được giữ giá trị trong suốt thời gian của nhiệm
vụ thời gian thực ( nhìn chương trước giải thích kỹ hơn cấu trúc RT_TASK)
rt_thread là sự thực hiện của nhiệm vụ, trong đó rt_thread là con trỏ toàn
bộ của hàm nhiệm vụ. nhiệm vụ cha có thể cho qua số nguyên đơn tới hàm.
data là các dữ liệu được truyền tới nhiệm được tạo ra. Để gọi lại kiểu
khuôn đúc cho phép dữ liệu để trỏ tới cấu trúc dữ liệu như qua nhiệm vụ, vì vậy
bạn có thể gián tiếp qua cái bạn muốn tới nhiệm vụ.
stack_size miêu tả chung kích thước sử dụng bởi nhiệm vụ mới, luôn
luôn gọi lại phòng cho điều khiển ngắt thời gian thực, nhu ngắt thời gian thực
chạy trong nhiệm vụ chúng ngắt. vì vậy thử tránh sơ sài.
priority là ưu tiên nhiệm vụ được tạo ra, ưu tiên cao nhất là 0. trong khi
thấp nhất là RT_LOWEST_PRIORITY. (xem các chương trước miều tả về ưu
tiên) int uses_fpu định nghĩa nếu nhiệm vụ sử dụng hay không FPU, uses_fpu
là cờ. Giá trị khác không chỉ thị nhiệm vụ sẽ được dùng đơn vị con trỏ động.
signal (void) là hàm được gọi, trong môi trường nhiệm vụ và với ngắt
được loại bỏ, khi nhiệm vu trở thành nhiệm vụ chạy hiện tại sau khi chuyển
khóa. Chú ý tuy nhiên signal là không được gọi lịch đầu tiều của nhiệm vụ,
Như hàm có thể gán và/hoặc thay đổi đông khi cần thiết, nhình hàm
rt_task_signal_handler.
Cho rt_task_init_cpuid cũng là một thông số để gán no tới CPU đơn từ
nó khi bắt đầu. Trong khi nếu rt_task_init api là được sử dụng RTAI với hoạt
động như sau; khi sử dụng với MUP hàng đợi rt_task_init tự động chọn CPU
nhiệm vụ sẽ chạy, trong khi với hàng đợi SMP nhiệm vụ mặc định được sử
dụng với cái CPU có giá trị. Sự gán này có thể thay đổi bằng cách gọi
rt_set_runnable_on_cpus hoặc rt_set_runnble_on_cpuid. Nếu cpuid là không có
giá trị rt_task_init_cpuid quay ngược tới sự lựa chọn CPU tự động. Mặc dù
hàng đợi được gán bởi hệ thống nhiều vi xử lý cho phép tạo ra nhiệm vụ và gán
nó tới các CPU đơn chỉ định từ khi bắt đầu, không cần bất kỳ lời gọi
rt_set_runnable_on_cpuid.
Sự trả về:
Thành công 0 được trả về trong khi nếu một số âm sẽ diễn giải lý
do như lỗi:
EINVAL cấu trúc nhiệm vụ được trỏ đã được sử dụng.
ENOMEM các stack_size không thể chỉ định cho nhiệm vụ

Trong khi module rtai_lxrt là được dùng, có hai API ẩn rtai_kthread_init

và nhiệm vụ là được định nghĩa như chúng ta đã giải thích,
Đã giới thiệu api này, nó là đơn giản để hiểu làm thể nào để sử ví dụ để
cho phép truy nhập thời gian thực.
Example 2 rtai_kernel_mode_task.c:
#include <linux/module.h>
#include <asm/io.h>
#include <rtai.h>
#include <rtai_sched.h>
static RT_TASK Simple_Task;
MODULE_LICENSE(“GPL”);
static void Simple_Thread(int t)
{
//This is the real-time thread
}
int init_module(void)
{p
rintk(“Init module function starting point\n”);
rt_task_init(&Simple_Task, Simple_Thread, 0, 3000, 0, 0, 0);
rerturn 0;
}
void cleanup_module(void)
{
printk(“Cleanup module function starting point\n”);
}

RT_TASK *rt_task_init (unsigned long name, int priority, int stack_size, int
max_msg_size)

RT_TASK *rt_task_init_schmod (unsigned long name, int priority, int

stacj_size, int max_msg_size, int policy, int cpus_allowed)
 Như bạn có thể nhìm có hai lựa chọn để tạo nhiệm vụ thời gian thực
trong chế độ người dùng, trong đó rt_task_init có thể bao gồm đơn giản hơn và
vì vậy lệnh tắt; dù như nào tất cả chúng có thể sử dụng cho mục đính này. Bản
nghi đầu tiên được định nghĩa như sau;
RTAI_PROTO(RT_TASK *,rt_task_init,(unsigned long name,
int priority, int stack_size, int max_msg_size))
{
return rt_task_init_schmod(name, priority, 0,
max_msg_size, SCHED_FIFO, 0xFF);
}
Nó nghĩa là nó được sử dụng quy định SCHED_FIFO and đặt
cpus_allowed tới 0xFF;
Tóm tắt lịch sử:
Lần đầu tiên hàm thực hiện chuyển từ nhiệm vụ Linux vào thời
gian thực RTAI ( cứng hoặc mềm (với make_hard/make_soft) là rt_task_init.
Luôn luôn trong khi sau đó, nó trở thành cần thiết để tạo ra kéo dài ra để đặt
trực tiếp ưu tiên lập lịch, và schmod phát triển đã giới thiệu nhanh

Chúng tạo ra nhiệm vụ

thời gian thực mới trong không gian người dùng, hoặc tốt hơn chúng tạo một
nhiệm vụ RTAI cho sử lý/nhiệm vụ Linux trong không gian người dùng.
rt_task_init mở rộng cấu trúc nhiệm vụ linux, tạo ra nó có thể để sử dụng
RTAI APIs cái muốn truy nhập phục vụ bộ lập lịch RTAI. Nó cần để không
hàm nhiệm vụ như là không để sử dụng, nhưng nó cần để cài đặt cấu trúc
nhiệm vụ RTAI và khởi tạo nó gần như dịch vụ phục vụ là được mang ra ngoài
như nếu Lunix sử trở thành nhiệm vụ RTAI, Bởi vì nó đòi hỏi ít tham số và trả
về con trỏ tới nhiệm vụ RTAI mở rộng, cái được sử dụng trong liên quan gọi.
Các tham số:
name: là định danh đơn nhất là có thể sử dụng bởi dễ dùng quy
chiếu nhiệm vụ RTAI mở rọng của điểm xử lý Linux.
priority là ưu tiên của nhiệm vụ RTAI mở rộng/
stack_size các tham số kế thừa không sử dụng hơn nưa, giữ cho lý
do khả chuyển ( nó là cái trì thực hiện bởi tên và quy chiếu tới kích thước
nhiệm vụ bởi sự thực hiện lần đầu của LXRT).
max_msg_size max_msg_size có thể là 0, trong trường hợp này
giá trị mặc định trong là được sử dụng. Giữ mắt như tin mặc định kích thước
256. Nó có thể là lớn hơn là yêu câu đẻ bạn cần tốt nhất. Trong trường hợp dịch
lại sys.c với macro MSG_SIZE là thích hợp, hoặc gán kích thước lớn hơn là rõ
ràng. Chú ý kích thước tin là không phê bình. Sự thực module được gán lại,
kích thước động và thích hợp, bất kỳ khi nào nó cần. Giá là bộ đệm mới với
thời gian thực. Chú ý max_msg_size là cho bộ đệm để sử dụng để sai chép
nhiệm vụ trong tin từ người dùng tới không gian nhân, như tin tác vụ nội là
không cần thiết được sử dụng trực tiếp.
Policy mặc định để SCHED_FIFO và nó có thể cũng là
RT_CHED_RR (nhìn sched_get_prioiry_max (policy)). Luật luân chuyển có
mục đích để sử dụng nếu bạn có vài nhiệm vụ, đang chạy với cùng mức ưu tiên
và không nhả CPU (khong rt_task_yield). Trong trường hợp luật RR sẽ chú ý
tới giới hạn chúng.
cpus_allowed là cpu khi bạn muốn nhiệm vụ chạy. Nó là một ít, Đây là bắt
buộc như RTAI muốn nhiệm vị chạy tĩnh trong CPU chỉ định. Nếu bạn muốn
đổi CPU sau đó tạo nhiệm vụ trả chú ý là sẽ giết chết thời gian thực. Nếu nhiều
bit được chỉ định RTAI tập trung nhiệm vụ này để chạy trên CPU đầu tiên bởi
giới hạn làm việc có thể.

Chú ý:
Đối với tin có tăng bộ nhớ động; bất kỳ thời gian kích thước của bộ đệm
là được loại trừ, hiện tại là được nhả và tạo cái mới, lớn hơn khoảng 20%, là
đang để tạo sử dụng RTAI heap realtime. Hoạt động là được giám sát thời gian
ám ảnh (luông nói chúng ta), vì vậy nó là đề xuất mạnh hơn để định nghĩa kích
thước đúng từ khi mỗi trạng thãi được khởi tạo cho hiệu năng lớn nhất.

Giải thích nhiệm vụ.

Cho dù phục vụ macro: grow_and_lock_stack (granted_stack_size) không làm

cả hai nhiệm vụ mở rộng và mlockall; được định nghĩa như sau:
#define rt_grow_and_lock_stack (incr) \
do
{\
char buf [incr]; \
memset(buf, 0 , incr); \
mlockall (MCL_CURRENT | MCL_FUTURE); \
} while (0)

nó là quan trọng để ddeeys rằng con trỏ trả nhiệm vụ không thể sử trực tiếp,
chúng là dữ liệu không gian nhân, nhung thông qua như tham số nếu cần.

Trả về:
Thành công con trỏ trỏ tới nhiệm vụ cấu trúc khởi tạo trong không
gian nhân.
Thất bại giá trị không được trả về nếu nó không thể để cài nhiệm
vụ bạn hoặc vào thứ đanh sử dụng cùng tên đã tìm thấy.
Ví dụ đơn giản để làm thế nào thực hiện tạo nhiệm vụ trong chế độ người sử
dụng theo sau:
Example 3 rtai_user_mode_task.c:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <rtai_lxrt.h>
#include <sys/io.h>
static RT_TASK *main_Task;
int main(void)
{
RT_TASK *Main_Task;
if (!(Main_Task = rt_task_init_schmod(nam2num("MNTSK"), 0,
0, 0, SCHED_FIFO, 0xF))) {
printf("CANNOT INIT MAIN TASK\n");
exit(1);
}
return 0;
}

Trong ví dụ này có hàm mới nam2num. Như bạn nhìn thấy, thông số đầu tiên
được đưa tới 2 hàm trên là một số unsigned long, nhưng để giảm khả có thể có,
bằng sai lầm, các số lặp lại, đặc biệt là nếu dự án của bạn là đủ phức tạp để yêu
cầu sự phóng túng nhiệm vụ, hàm này sẽ được dịch tên đơn nhất thành số tự
động, Điều này cũng cho phép bạn theo dấu nhiệm vụ bởi tên của nó trong các
bước xâu hơn không có sự hiểu nó với quan hệ unsigned long id. Có hai APIs
chỉ định với điều khiển tên chuyển thành số là:
unsigned long nam2num (const char *name)
void num2nam (unsigned long num, char * name)
Sự chuyển đổi đầu chuyển 6 ký tự sau thành một số unsigned long trong khi
sự chuyển đổi thứ 2 chuyển một số unsigned long thành sâu 6 ký tự. Cho phép
tất cả các ký tự:
. Ký tự tiếng anh (không phân biệt in hoa hay thường).
. số thập phân
. gạch dưới (_)
. Các ký tự khác bạn chọn có thể sử dụng nhưng chó ý chúng sẽ luôn
luôn chuyển đổi ngược lại thành $ bởi num2nam() vì vậy đơn gian tránh xa
chúng.
 Nó cũng có thể tránh phát sinh tên mới, nếu nó là không cần thiết, nếu
nó là gần gũi, bạn có thể muốn sử dụng rt_get_name(NULL). RTAI đảm bảo
tên đơn nhất giữa 700000000 khả năng.
6.1.3. Bắt đầu bộ thời gian
Trong chế độ nhân thời gian thực mới được tạo ra để khởi tạo
trong trạng thái treo ( nó là không giá trị trong chế độ người
dùng). Nó thể được tích cực bởi lời gọi:
rt_task_make_periodic, rt_task_make_periodic_relative_ns
và rt_task_resume. nhưng trước sử dụng chúng, nó bắt buộc
phải khởi động timer. bộ thời gian là bước chính để cho phép
đon thời gian ép buộc trong tạo nhiệm vụ RTAI. Bộ thời gian có
thể bắt đầu hoặc dừng lại với theo API định nghĩa trong
“rta_sched.h:
RTIME start_rt_timer (int period);
void stop_rt_timer(void);
start_rt_timer bắt đầu thời gian với chu kỳ period. Chu kỳ
là đơn vị đếm trong và nó đòi hỏi chỉ cho chế độ chu kỳ. Trong
chế độ oneshot chu kỳ là giá trị bị bỏ qua.
Các hàm này sử dụng 8254 hoặc APIC địa phương với APC
cơ bản nhân/hàng đợi. Trong các trường hợp muộn hơn tất cả
các thời gian APIC là cùng, qua chế độ thời gian.
stop_rt_timer dừng bộ thời gian. chế độ thời gian được đặt
chu kỳ,
Trả về:
Chu kỳ trong bộ đếm trong.
chú ý:
Nếu dự án của bạn chạy ở chế độ đa nhiệm sự trả giá để
bắt đầu chỉ là một bộ thời gian và để tránh dừng nó khi một
trong nhiệm vụ của bạn thoát, ngoài ra bộ timer sẽ dừng lại
cho các cái khác. Nếu bạn bắt đầu bộ thời gian nhiều hơn sau
đó một cái thứ hai được gọi sẽ đặt lại bộ thời gian và nó với chu
kỳ mới. Để kiể, tra nếu bộ thời gian cứng là đang chạy bạn có
thể sử dijng rt_is_hard_timer_running () API. Bạn có thể cũng sử
dụng nano2count macro với chuyển giá trị từ nano giây thành
đơn vị đếm trong
Example 4 how to start up a timer:
#define TICK_TIME 1000000
if ((hard_timer_running = rt_is_hard_timer_running()))
{
printf("Skip hard real_timer setting...\n");
sampling_interval = nano2count(TICK_TIME);
}
else
{p
rintf("Starting real time timer...\n");
rt_set_oneshot_mode();
start_rt_timer(0);
}
sampling_interval = nano2count(TICK_TIME);
6.1.4. Chế độ Oneshot và chu kỳ.
Bây giời nó là thời điển để giải quyết với chế độ bộ thời gian
bạn muốn để chạy. Bạn có thể chọn giữa oneshot và chu kỳ.
Hai hàm API chỉ định, định nghĩa trong “rtai_sched.h” được sủ
dụng như sau:
void rt_set_oneshot_mode (void)
void rt_set_periodic_mode (void)l.

Nếu bạn không muốn đặt chế độn hãy chú thích đó là mặc định là chu kỳ
rt_set_oneshot_mode đặt chế độ oneshot cho bộ thời gian. Nó bao gồm
trong giá trị thời gian cơ bản của đồng hồ CPU. Điều này cho phép nhiệm vụ có
thể độc chiếm thời gian. Nó phải được gọi trước khi sử dụng bất kỳ thời gian
liên quan hàm. bao gồm của thời gian chuyển đổi. Chú ý ở i386, i486s và dòng
pentiums sớm hơn, và tương thích, không có CPU Time Stamp Clock (TSC) để
sử dụng như bộ thời gian chạy liên tục cho thời gian oneshot. Như các máy
chạy liên tục bộ đếm 2 của 8254 được sử dụng để mô phỏng TSC. Không có
bọc quang nguy hiểm tồn tại bởi vì cần giữa jiffies Linux tại mức Hz (Hz là
macro được tìm thấy trong Linux param,h và luon được đặt là 100). Chú ý đọc
một 8254 đếm mất một thời gian. Vì vậy các mấy chế độ oneshot có thể được
sử dụng chỉ khi nếu nó nghiêm khac cần và để cho tần số không quá cao. Ngoài
ra, cho các trường hợp này, độ phân giải của 8254 ví dụ 1193180 Hz
rt_set_periodic_mode đặt chế độ chu kỳ cho bộ thời gian. Nó bao gồm
tần số cố định của nhiệm vụ trong nhiều chu kỳ đặt với lời gọi start_rt_timer.
Sự phân giải 8254 (1193180), hoặc thời gian bởi bộ thời gian địa phương APIC
và cho phép với độ phân giải bộ thời gian của tần số thời gain địa phương, tạo
ra tần số bus chia 16. Bất kỳ yêu câu về thời gian không bắt đầu bởi một số
nguyên của chu kỳ thời gian được đặt là hài lòng gần chu kỳ nhjp. Nó là mặc
định khi không có lời gọi được tạo ra để đặt chế độ oneshop. Chế độ Oneshop
có thể được khởi tạo cũng với lện OneShop của rtai_sched module.
Chú ý:
Dừng bộ thời gian bởi stop_rt_timer đặt bộ thời gian quay ngược
lại chế độ mặc định. Luôn cho phép gọi rt_set_oneshot_mode trước mỗi
start_rt_timer nếu bạn muôn chắc chắn để có oneshot trên nhiều insmod không
tháo bỏ rmmoding RTAI bộ lập lịc trong dùng.
Với start_rt_timer(0) chế độ oneshot là tự động tập trung.
Cũng có rt_is_hard_timer_running API để hiểu nếu bộ thời gian là
đã đang chạy; API có thể sủ với chú ý như nó có thể phát điều khiện “race”.
Nó là quan trọng để gọi start_rt_timer API trước sử dụng bất kỳ
chức năng cái đó giải quyết với thời gian, mặc khác tất cả các giá trị là có thể
lỗi.

6.1.5. Sự chạy các nhiệm vụ chu kỳ

Tại giai đoạn này bộ thời gain là đang chạy với chu kỳ thích hợp và qua
quy định bộ thời gian lựa chọn (onshot và chu kỳ) nó sẽ cho phép đặt nhiệm vụ
thời gian thực cho hàng đợi chu kỳ. Nó có thể giành được với API sau:
int rt_task_make_periodic (RT_TASK *task, RTIME start_time,
RTTIME period);
int rt_task_make_periodic (RT_TASK *task, RTIME start_delay,
RTTIME period);

Chúng tạo nhiệm vụ chạy chu kỳ, hơn nữa rt_task_make_periodic đánh
dấu nhiệm vụ task, được tạo trước bởi rt_task_init(), phù hợp cho chạy chu kỳ,
với chu kỳ period, khi rt_task_wait_period () được gọi. Thời gina của sự chạy
đầu tiền là được định nghĩa thông qua start_time hoặc start_delay. start_time là
giá trị tuyệt đối đo được trong nhịp đồng hồ. start_delay là quan hệ để thời gian
chạy hiện tại và đo được trong nano giây.

Để rễ ràng với nhịp đồng hồ và với nano giây có 2 macro được định
nghĩa. luôn đặt ở trong “rtai_sched.h” sẽ giúp bạng; chúng có tên là count2nano
và nano2counts. Chúng được định nghĩa là:
RTIME count2nano (RTIME timercounts);
RTIME nano2count (RTIME nanosecs);

Chúng đơn giản chuyển đổi các đơn vị thời gian, nhưng bạn phải nhớ
các đơn vị đếm là qua hệ với chế độ thời gian được lựa chọn (oneshot/chu kỳ).

RTIME là được định nghĩa khiểu long long.

Các tham số :
task là con trỏ trỏ tới nhiệm vụ bạn muốn chạy chu kỳ.
start_time là giá trị thời gian tuyệt đối để đợi trước khi nhiệm vụ
bắt chạy và nó là trong nhịp đồng hồ chu kỳ đáp ứng để chu kỳ của nhiệm vụ,
trong nhịp đồng hồn.
 Trả về :
0 là thành công và giá trị âm là lỗi, có thể là EINVAL nếu nhiệm
vụ kkhoong tìm được nhiệm vụ có giá trị.
Chú ý :
Sự gọi lại giới hạn nhịp đồng hồ phụ thuộc vào chế độ trong các
bộ thời gian cứng chạy. Vì nếu bộ thời gian cứng đã được đặt như chu kỳ nhịp
đồng hồ sẽ chu kỳ cuối cùng trong start_rt_timer, trong khi nếu chế độ oneshop
là được sử dụng nhịp đồng hồ sẽ tần số chạy đảo cuối cùng của bộ thời gian
cứng trong sử dụng và bất kể chu kỳ nào sử dụng trong lời gọi để
start_rt_timer.
Nếu bạn sử dụng rt_task_make_periodic API xa hơn, chú ý tham số thứ
hai, thên start_delay là quan hệ với thời gian hiện tại và đo trong nano giây.

void rt_make_hard_real_time (void) ;

void rt_make_soft_real_time (void);

Có API đưa linux sử lý của pthread sự chạy thời gian thực cứng kiểm
định, nó cho phép đầy để quyền ưu tiên trước RTAI, hoặc mềm để trả nhiệm vụ
thời gian thực cứng để Linux chuẩn chạy. đặc biệt hơn rt_make_hard_real_time
tạo sử lý thời gian thực POSIX linux mềm, từ cái gọi nó, xử lý LXRT thời gian
thực cứng. Nó là quan trọng để đánh dấu hàm này phải được sử dụng chỉ khi
với sử lý POSIX linux mềm có bộ nhớ nó khóa trong bộ nhớ. Trong khi
rt_make_soft_real_time trả về sử lý thời gian thực mềm Linux POSIC, từ cái
nó là được gọi, cái này tạo thời gian thực cứng được gọi từ
rt_make_hard_real_time.
Chỉ có sử xử lý nó tự chạy có thể sử dụng các hàm này, nó là không thể
để lạm dụng liên quan sự truyền từ các bộ sử lý; sự kiện nếu có chế độ để tập
trung nhiệm vụ mềm từ các cái khác (rt_force_task_soft (int pid) – có tiện ích
ẩn để hiểu làm thế nào nó hoạt động trong sự liên kết với cat /proc/rtai/*; là các
mảng của phần mền, luôn luôn trong lưu trữ phòng trưng bày – nhìn
showroom/v3.x/user/latency).
SYSCALL và TRAP
Chú ý nhiệm vụ thời gian thực chế độ người dùng có thể chạy chu kỳ
cho tới không có bất kỳ lời gọi hệ thống Linux hoặc bất kỳ lời gọi tới thư viện,
với các yêu cầu phụ vụ linux thuần túy. Trong trường hợp này thời gian thực ép
buộc không thể bảo đảm không hơn, như nhiệm vụ sẽ chuyển sang linux điều
khiển. Nếu sự này bạn sẽ được báo. Trong nhân tin nhắn ra (type dmesg để
hiểu), bởi vài dòng như sau:
LXRT CHANGED MODE (SYSCALL), PID = xxx, SYSCALL = yyy.
Dòng này báo bạn ứng dụng thời gian thực của bạn có sự cho phép sự
gọi linux đầu tiên, vì vậy mất thời gian thực cho thời gian cần thiết phụ vụ nó.
Bọn cũng hiểu PID của ứng dụng ứng dụng “tội phạm” chỉ định. Nếu nó được
chấp nhận không có vấn đề, bạn không có nhìn mã của bạn để khám phá tại sao
linux là được gọi với thời gian thực. Theo lời gọi hệ thống không báo lại với
message nhưng đơn giản sự đếm và hiện thỉ với RTAI file. Sự xảy ra tương tự
cho bẫy hệ thống. Bất kỳ như thế nào RTAI thử trả về để thời gian thực cứng
sớm nhất có thể, nhưng lập lịch là trong Linux điều khiển chạy là không dự
đoán được, như nó là chích.
Như giải pháp để ảnh hưởng với Linux bạn có cặp sử lý được tạo ra thời
gian thực cứng với phục vụ bạn thân Linux, hoặc thời gian thực mềm chuẩn
hoặc POSIX. Để giao tiếp và đồng bộ với bạn thân bạn có thể sử dụng sức khỏa
của giá trị RTAI, và bộ lập lịch của nó phục vụ. Sau đó tất cả vô nghĩa nguyên
để sử dụng hệ điều hành không thời gian thực cứng, ví dụ linux, từ sử lý trong
thời gian thực và luôn luôn nhớ nhưng thứ đó.
Tất cả báo trước cho phép chỉ moojtl khi điều kiện đầu xảy ra, nếu có
nhiều hơn lời gọi hệ thống hoặc bẫy báo chúng được đếm và thấy với lệnh
cat /proc/rtai/*.
Example 5 making a task periodic (in user mode):
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <rtai_lxrt.h>
#include <sys/io.h>
#define TICK_TIME 1000000
#define CPUMAP 0x1
static RT_TASK *main_Task;
static RT_TASK *loop_Task;
int keep_on_running = 1;
static pthread_t main_thread;
static RTIME expected;
static RTIME sampling_interval;
static void *main_loop()
{
if (!(loop_Task = rt_task_init_schmod(nam2num("RTAI01"), 2,
0, 0, SCHED_FIFO, CPUMAP))) {
printf("CANNOT INIT PERIODIC TASK\n");
exit(1);
}
expected = rt_get_time() + 100*sampling_interval;
rt_task_make_periodic(loop_Task, expected,
sampling_interval);
rt_make_hard_real_time();
while (keep_on_running)
{/
/insert your main periodic loop here
rt_task_wait_period();
//set keep_on_running to 0 if you want to exit
}
rt_task_delete(loop_Task);
return 0;
}
int main(void)
{
RT_TASK *Main_Task;
if (!(Main_Task = rt_task_init_schmod(nam2num("MNTSK"), 0,
0, 0, SCHED_FIFO, 0xF))) {
printf("CANNOT INIT MAIN TASK\n");
exit(1);
}
if ((hard_timer_running = rt_is_hard_timer_running()))
{p
rintf("Skip hard real_timer setting...\n");
sampling_interval = nano2count(TICK_TIME);
}
else
{
printf("Starting real time timer...\n");
rt_set_oneshot_mode();
start_rt_timer(0);
}
sampling_interval = nano2count(TICK_TIME);
pthread_create(&main_thread, NULL, main_loop, NULL);
while (keep_on_running)
sampling_interval = sampling_interval; //do nothing!
rt_task_delete(Main_Task);
return 0;
}
6.1.7. RTAI làm chủ sự tạo các lời gọi tắt cho thread (luồng).
Có vài hàm tiện ích cho phép bạn tạo thread không có sử dụng hàm
pthread_create POSIX chuẩn, pthread_init và pthread_join.
 int rt_thread_create (void *fun, void * args, int stack_size)l
int rt_thread_join (int thread);
int rt_thread_init (unsigned long name, int priority, int max_msg_size,
int policy, init cpus_allowed);

Tất cả các API là được định nghĩa trong rtai_lxrt.h gồm file và, như bạn
báo trước file này, chúng là được gọi trực tiếp hàm liên quan Posix chuẩn trong
cách trong suốt và hiệu quả. Thêm vào đó chúng chấp nhận nhiều thông số hơn
trong điều chỉnh bước 1, như stack_size cho rt_thread_create hoặc gọi trực tiếp
rt_task_init_schmod cho rt_thread_init.
Cơ bản bạn phải cân nhắc xem chúng là tiện dụng và an toàn liên kết tát
để tạo ra chức năng nhiệm vụ RTAI. Sự thật chúng trở thành lan rộng nhiều
hơn giữa người sử dụng giao tiếp RTAI. Bất kết như thế nào nó là rành mạch,
nhìn ví dụ trước, các API là lựa chọn như bạn có thể tạo nhiệm vụ không có
chúng; nhưng bạn sẽ bắt đầu sử dụng liên kết tăt nó sẽ khó để quay lạo cách
khả chuyển.
6.2. Thời gian là gì.
Sự phân chia thời gian, trong nano giây hoặc trong bộ đơn đếm trong là
quan trọng vẻ bề ngoài của nhiệm vụ thời gian thực, Như sự thật có vài API
dành riêng để là điều đó; chúng được định nghĩa trong “rtai_sched.h”:

RTIME rt_get_time (void);

RTIME rt_get_time_cupid (int cpuid);
RTIME rt_get_time_ns (void);
RTIME rt_get_cpu_time_ns (void);
RTIME rt_get_time_ns_cpuid (int cpuid);
rt_get_time trả lại thời gian, đơn vị đếm trong, từ khi start_rt_Timer
được gọi. Trong chế độ chu kỳ là số trong nhiều nhịp chu kỳ, Chế độ oneshop
là trực tiếp đếm TSC cho CPU có time stamp clock (TSC), trong khi nó là đơn
vị 8254 cho cái không có (nhìn hàm rt_set_oneshot_mode và
rt_set_periodic_mode diễn giải).
rt_get_time_ns là tương tự như rt_get_time nhưng trả vè thời gian được
chuyển đổi sang nano giây.
rt_get_cpu_time_ns luôn trả vè thời gian CPU trong nano giây mọi bộ
thời gian là trong sử dụng. Phiên bản kết thúc với _cpuid phải được sủ dụng
trên máy đa xử lý khi cần để khai bái từ cpuid thời gian phải có. Sự thực có thể
cần để có thời của CPU khác và bộ thời gian có thể khác từ CPU tới CPU.
Đồng hồ đồng bộ trên MP
Trong các hệ thống đa xử lý nó là rất quan trọng để kiểm tra sự khác
nhau giữa tất cả các đơn vị TSC bởi vì bất kỳ lỗi thời gian có thể chỉ đạo
chương trình tiềm tãn vấn đề hoặc ít nhất làm hỏng hoạt động. Trường hợp tiêu
biểu là nhiệm muốn đánh thức một nhiệm vụ khác trong chạy trên các CPUs;
Nếu hai đồng hồ là không đồng bộ kết quả là không dự đoán được, Đây là điều
kiện hiến như các kinh nghiệm đã thể hiện các CPU là đồng bộ rất tốt (sub us)
nhưng cũng có vài phần cứng với đồng hồ dạt hoạt lỗi đồng bộ. Luôn luôn là có
vần đề RTAI để tiềm tàng cho phép, Nó là phần nhỏ của phần mêm tên
tscsync, có trong kho lưu trữ phòng trương bày. Thêm vào đó, cho các phiên
bản RTAI tương lai, sẽ có cài đặt đầy đủ hỗ trợ cho phép phân tích và điều
chỉnh đúng. Đó là không tầm thường, sẽ có trong tương lai, tiến tới dual core là
kỳ vọng để ngày càng mở rộng.

Trả về:
Thời gian hiện tại trong đơn vị đếm trong/nano giây được trả về.
Chú ý:
Có thể sử dụng RTC như bộ thời gian; nó là chu kỳ trong đó nhịp
là tại nguồn của 2. Đây là cơ hội tốt chọn cho phần cứng không có thiết bị
TSC ; bởi vì nó tránh sử dụng 8254 và vì vậy để cận thận linux và nó là ngay
lập tức. ( Nhìn diễn giải trong danh mục cài đặt dưới “Base system” ->
“scheduling options”).