I denne artikel vil vi bruge egentlige systemopkald til at udføre reelt arbejde i vores C -program. Først gennemgår vi, om du skal bruge et systemopkald, og giver derefter et eksempel ved hjælp af opkaldet sendfile (), der dramatisk kan forbedre filkopieringseffektiviteten. Endelig vil vi gå over nogle punkter at huske, mens vi bruger Linux -systemopkald.
Selvom det er uundgåeligt, vil du bruge et systemopkald på et tidspunkt i din C -udviklingskarriere, medmindre du er målrettet mod høj ydeevne eller en bestemt type funktionalitet, vil glibc -biblioteket og andre grundlæggende biblioteker inkluderet i større Linux -distributioner tage sig af størstedelen af dine behov.
Glibc-standardbiblioteket giver en tværgående platform, godt testet ramme til at udføre funktioner, der ellers ville kræve systemspecifikke systemopkald. For eksempel kan du læse en fil med fscanf (), fread (), getc () osv., Eller du kan bruge read () Linux -systemopkald. Glibc -funktionerne giver flere funktioner (dvs. bedre fejlhåndtering, formateret IO osv.) Og fungerer på alle systemglibc -understøttelser.
På den anden side er der tidspunkter, hvor kompromisløs ydeevne og nøjagtig udførelse er kritisk. Den indpakning, som fread () leverer, vil tilføje overhead, og selvom den er mindre, er den ikke helt gennemsigtig. Derudover har du måske ikke brug for eller har brug for de ekstra funktioner, indpakningen giver. I så fald er du bedst tjent med et systemopkald.
Du kan også bruge systemopkald til at udføre funktioner, der endnu ikke er understøttet af glibc. Hvis din kopi af glibc er opdateret, vil dette næppe være et problem, men udvikling af ældre distributioner med nyere kerner kan kræve denne teknik.
Nu hvor du har læst ansvarsfraskrivelser, advarsler og potentielle omveje, lad os nu grave i nogle praktiske eksempler.
Hvilken CPU er vi på?
Et spørgsmål, som de fleste programmer nok ikke tænker at stille, men ikke desto mindre et gyldigt spørgsmål. Dette er et eksempel på et systemopkald, der ikke kan kopieres med glibc og ikke er dækket af en glibc -indpakning. I denne kode kalder vi opkaldet getcpu () direkte via funktionen syscall (). Syscall -funktionen fungerer som følger:
syscall(SYS_call,arg1,arg2,...);Det første argument, SYS_call, er en definition, der repræsenterer nummeret på systemopkaldet. Når du inkluderer sys/syscall.h, er disse inkluderet. Den første del er SYS_ og den anden del er navnet på systemopkaldet.
Argumenter for opkaldet går ind i arg1, arg2 ovenfor. Nogle opkald kræver flere argumenter, og de fortsætter i rækkefølge fra deres man -side. Husk, at de fleste argumenter, især for returneringer, vil kræve pointer til char -arrays eller hukommelse tildelt via malloc -funktionen.
eksempel1.c
#omfatte#omfatte
#omfatte
#omfatte
intvigtigste() {
usigneretcpu,knudepunkt;
// Få den nuværende CPU -kerne og NUMA -node via systemopkald
// Bemærk, at dette ikke har nogen glibc -indpakning, så vi skal kalde det direkte
syscall(SYS_getcpu, &cpu, &knudepunkt,NUL);
// Vis oplysninger
printf ('Dette program kører på CPU -kerne %u og NUMA -knude %u. n n',cpu,knudepunkt);
Vend tilbage 0;
}
At kompilere og køre:
gcc eksempel 1.c -o eksempel 1
./eksempel 1
For mere interessante resultater kan du spinde tråde via pthreads -biblioteket og derefter kalde denne funktion for at se på hvilken processor din tråd kører.
Sendfil: Overlegen ydeevne
Sendfile giver et glimrende eksempel på forbedring af ydeevnen gennem systemopkald. Sendfile () -funktionen kopierer data fra en filbeskrivelse til en anden. I stedet for at bruge flere fread () og fwrite () funktioner, udfører sendfile overførslen i kernerum, reducerer overhead og derved øger ydeevnen.
I dette eksempel vil vi kopiere 64 MB data fra en fil til en anden. I en test vil vi bruge standard læse/skrive metoder i standard biblioteket. I den anden vil vi bruge systemopkald og opkaldet sendfile () til at sprænge disse data fra et sted til et andet.
test1.c (glibc)
#omfatte#omfatte
#omfatte
#omfatte
#define BUFFER_SIZE 67108864
#define BUFFER_1 'buffer1'
#define BUFFER_2 'buffer2'
intvigtigste() {
FIL*forkert, *ende;
printf (' nI/O -test med traditionelle glibc -funktioner. n n');
// Tag en BUFFER_SIZE buffer.
// Bufferen vil have tilfældige data i den, men det er vi ligeglade med.
printf ('Tildeling af 64 MB buffer:');
forkælelse *buffer= (forkælelse *) malloc (BUFFER_SIZE);
printf ('FÆRDIG n');
// Skriv bufferen til fOut
printf ('Skrivning af data til første buffer:');
forkert= fopen (BUFFER_1, 'wb');
fwrite (buffer, størrelse på(forkælelse),BUFFER_SIZE,forkert);
fclose (forkert);
printf ('FÆRDIG n');
printf ('Kopiering af data fra første fil til anden:');
ende= fopen (BUFFER_1, 'rb');
forkert= fopen (BUFFER_2, 'wb');
fread (buffer, størrelse på(forkælelse),BUFFER_SIZE,ende);
fwrite (buffer, størrelse på(forkælelse),BUFFER_SIZE,forkert);
fclose (ende);
fclose (forkert);
printf ('FÆRDIG n');
printf ('Frigørelsesbuffer:');
gratis (buffer);
printf ('FÆRDIG n');
printf ('Sletter filer:');
fjerne (BUFFER_1);
fjerne (BUFFER_2);
printf ('FÆRDIG n');
Vend tilbage 0;
}
test2.c (systemopkald)
#omfatte#omfatte
#omfatte
#omfatte
#omfatte
#omfatte
#omfatte
#omfatte
#omfatte
#define BUFFER_SIZE 67108864
intvigtigste() {
intforkert,ende;
printf (' nI/O -test med sendfile () og relaterede systemopkald. n n');
// Tag en BUFFER_SIZE buffer.
// Bufferen vil have tilfældige data i den, men det er vi ligeglade med.
printf ('Tildeling af 64 MB buffer:');
forkælelse *buffer= (forkælelse *) malloc (BUFFER_SIZE);
printf ('FÆRDIG n');
// Skriv bufferen til fOut
printf ('Skrivning af data til første buffer:');
forkert=åben('buffer1',O_RDONLY);
skrive(forkert, &buffer,BUFFER_SIZE);
tæt(forkert);
printf ('FÆRDIG n');
printf ('Kopiering af data fra første fil til anden:');
ende=åben('buffer1',O_RDONLY);
forkert=åben('buffer2',O_RDONLY);
Send fil(forkert,ende, 0,BUFFER_SIZE);
tæt(ende);
tæt(forkert);
printf ('FÆRDIG n');
printf ('Frigørelsesbuffer:');
gratis (buffer);
printf ('FÆRDIG n');
printf ('Sletter filer:');
fjerne tilknytningen('buffer1');
fjerne tilknytningen('buffer2');
printf ('FÆRDIG n');
Vend tilbage 0;
}
Kompilering og kørselstest 1 & 2
For at bygge disse eksempler skal du have udviklingsværktøjerne installeret på din distribution. På Debian og Ubuntu kan du installere dette med:
passendeinstallerebuild-essentialsKompiler derefter med:
gcctest1.c-ellertest1&& gcctest2.c-ellertest2For at køre begge og teste ydelsen skal du køre:
tid./test1&& tid./test2Du skal få resultater som dette:
I/O -test med traditionelle glibc -funktioner.
Tildeling af 64 MB buffer: FÆRDIGSkrivning af data til første buffer: FÆRDIG
Kopiering af data fra første fil til anden: FÆRDIG
Frigørelsesbuffer: FÆRDIG
Sletning af filer: FÆRDIG
ægte 0m0.397s
bruger 0m0.000s
sys 0m0.203s
I/O -test med sendfile () og relaterede systemopkald.
Tildeling af 64 MB buffer: FÆRDIG
Skrivning af data til første buffer: FÆRDIG
Kopiering af data fra første fil til anden: FÆRDIG
Frigørelsesbuffer: FÆRDIG
Sletning af filer: FÆRDIG
ægte 0m0.019s
bruger 0m0.000s
sys 0m0.016s
Som du kan se, kører koden, der bruger systemopkald, meget hurtigere end glibc -ækvivalent.
Ting at huske
Systemopkald kan øge ydeevnen og give yderligere funktionalitet, men de er ikke uden deres ulemper. Du bliver nødt til at afveje de fordele, systemopkald giver mod manglen på platformportabilitet og undertiden reduceret funktionalitet i forhold til bibliotekfunktioner.
Når du bruger nogle systemopkald, skal du passe på at bruge ressourcer, der returneres fra systemopkald frem for biblioteksfunktioner. For eksempel er FILE -strukturen, der bruges til glibc's fopen (), fread (), fwrite () og fclose () funktioner ikke det samme som filbeskrivelsesnummeret fra det åbne () systemopkald (returneres som et helt tal). Blanding af disse kan føre til problemer.
Generelt har Linux -systemopkald færre kofangerbaner end glibc -funktioner. Selvom det er rigtigt, at systemopkald har en vis fejlhåndtering og rapportering, får du mere detaljeret funktionalitet fra en glibc -funktion.
Og endelig et ord om sikkerhed. Systemopkald interface direkte med kernen. Linux -kernen har en omfattende beskyttelse mod shenanigans fra brugerland, men der findes uopdagede fejl. Stol ikke på, at et systemopkald vil validere dit input eller isolere dig fra sikkerhedsproblemer. Det er klogt at sikre, at de data, du afleverer til et systemopkald, er desinficeret. Dette er naturligvis et godt råd til ethvert API -opkald, men du kan ikke være forsigtig, når du arbejder med kernen.
Jeg håber, at du nød dette dybere dyk i landet med Linux -systemopkald. For en komplet liste over Linux -systemopkald, se vores masterliste.