RTOS vs GPOS
GPOS:- no time boundation,task hasnt got any time limit to finish work.
-------------------
An RTOS is a special case of GPOS.
1. In RTOS every task must have a priority.
2. Pre-emption is a must feature.
3. Priority Inheritance is must otherwise priority
inversion may cause unbounded wait.
-------------------
RTOS:- time boundation, task has to complete work within
given time frame. For this preemtive scheduling is must.OS uses Round
Robin scheduling.
-------------------
GPOS USES A MONOLITHIC ARCHITECTURE WHILE RTOS USES A FLAT MEMORY ARCHITECTURE.
#include <stdio.h>
#include <stdlib.h>
int main() {
int c, n;
printf("Ten random numbers in [1,100]\n");
for (c = 1; c <= 10; c++) {
n = rand()%100 + 1;
printf("%d\n", n);
}
return 0;
}
Algorithm: getParity(n)
1. Initialize parity = 0
2. Loop while n != 0
a. Invert parity
parity = !parity
b. Unset rightmost set bit
n = n & (n-1)
3. return parity
Example:
Initialize: n = 13 (1101) parity = 0
n = 13 & 12 = 12 (1100) parity = 1
n = 12 & 11 = 8 (1000) parity = 0
n = 8 & 7 = 0 (0000) parity = 1
Code:
# include <stdio.h># define bool intbool getParity(unsigned int n){ bool parity = 0; while (n) { parity = !parity; n = n & (n - 1); } return parity;}int main(){ unsigned int n = 7; printf("Parity of no %d = %s", n, (getParity(n)? "odd": "even")); getchar(); return 0;} |
# include<stdio.h>int main(){ int n = 687; printf(" %d ", getSum(n)); getchar(); return 0;}/* Function to get sum of digits */int getSum(int n){ int sum; /*Single line that calculates sum*/ for(sum=0; n > 0; sum+=n%10,n/=10); return sum;} |
int sumDigits(int no){ return no == 0 ? 0 : no%10 + sumDigits(no/10) ;}int main(void){ printf("%d", sumDigits(1352)); getchar(); return 0;}Prime Number Generation upto a specific count:
#include<stdio.h>
main()
{
int n, i = 3, count, c;
printf("Enter the number of prime numbers required\n");
scanf("%d",&n);
if ( n >= 1 )
{
printf("First %d prime numbers are :\n",n);
printf("2\n");
}
for ( count = 2 ; count <= n ; )
{
for ( c = 2 ; c <= i - 1 ; c++ )
{
if ( i%c == 0 )
break;
}
if ( c == i )
{
printf("%d\n",i);
count++;
}
i++;
}
return 0;
}
There are many logic to check prime numbers, one given below is more
efficient then above method. for ( c = 2 ; c //only checking from 2 to square root of number is sufficient.
#include<stdio.h>
main()
{
int n, c = 2;
printf("Enter a number to check if it is prime\n");
scanf("%d",&n);
for ( c = 2 ; c <= n - 1 ; c++ )
{
if ( n%c == 0 )
{
printf("%d is not prime.\n", n);
break;
}
}
if ( c == n )
printf("%d is prime.\n", n);
return 0;
}
Prime Numbers Less than a number:
#include <stdio.h>
#include <iostream>
int main()
{
int n,i=1,j,c;
printf("Enter Number Of Terms");
printf("Prime Numbers Are Following\n");
scanf("%d",&n);
while(i<=n)
{
c=0;
for(j=1;j<=i;j++)
{
if(i%j==0)
c++;
}
if(c==2)
printf("%d\n",i);
i++;
}
system("pause");
return 0;
}
Efficient Method for Prime Numbers:
int by2(int x): x << 1 // do left shift of x to divide it by 2
divide(x,y):
if(x=0):
return (q,r)=(0,0)
(q,r) = divide (by2(x),y)
q=2*q, r=2*r
if x is odd
r=r+1
if(r>=y)
r=r-y, q=q+1
return (q,r)eg. Total # of instances of resource = 12 (Max, Allocated, Still Needs) P0 (10, 5, 5) P1 (4, 2, 2) P2 (9, 2, 7) Free = 3 - Safe The sequence is a reducible sequence the first state is safe. What if P2 requests 1 more and is allocated 1 more instance? - results in Unsafe state So do not allow P2's request to be satisfied.
n process and m resources
Max[n * m]
Allocated[n * m]
Still_Needs[n * m]
Available[m]
Temp[m]
Done[n]
while () {
Temp[j]=Available[j] for all j
Find an i such that
a) Done[i] = False
b) Still_Needs[i,j] <= Temp[j]
if so {
Temp[j] += Allocated[i,j] for all j
Done[i] = TRUE}
}
else if Done[i] = TRUE for all i then state is safe
else state is unsafe
}
HashSet (or other near-O(1)) data structure available then this is what you can do:
Intersection of two sorted Lists:
http://www.geeksforgeeks.org/intersection-of-two-sorted-linked-lists/
List getIntersection(int[] a, int[] b){
int apos = 0, bpos = 0
List intersection
while apos < a.length && bpos < b.length:
if a[apos] == b[bpos]:
intersection.add(a[apos])
apos++, bpos++
else:
if a[apos] < b[bpos]:
apos++
else:
bpos++
return intersection
}
Efficiency is O(m + n).
Operator
|
Precedence
|
Associative
|
=
|
More than ,
|
Right to left
|
,
|
Least
|
Left to right
|
>>-type_specifier--+------------+--:--constant_expression--;---><
'-declarator-'
A bit field declaration contains a type specifier followed by an optional
declarator, a colon, a constant integer expression that indicates the field
width in bits, and a semicolon. A bit field declaration may not use
either of the type qualifiers, const or volatile.
The C99 standard requires the allowable data types for a bit field to
include qualified and unqualified _Bool, signed int, and
unsigned int. In addition, this implementation supports the
following types.
C++ extends the list of allowable types for bit fields to include any
integral type or enumeration type.
Bit fields are also subject to the align compiler option.
Each of the align suboptions gives a different set of alignment properties to
the bit fields. For a full discussion of the align compiler
option and the #pragmas affecting alignment, see XL
C/C++ Compiler Reference.
struct taxonomy {
int kingdom : 12;
int phylum : 6;
int genus : 2;
};
Alignment of Bit Fields
struct on_off {
unsigned light : 1;
unsigned toaster : 1;
int count; /* 4 bytes */
unsigned ac : 4;
unsigned : 4;
unsigned clock : 1;
unsigned : 0;
unsigned flag : 1;
} kitchen ;
The structure kitchen contains eight members totalling 16
bytes. The following table describes the storage that each member
occupies:
| Member Name | Storage Occupied |
|---|---|
| light | 1 bit |
| toaster | 1 bit |
| (padding -- 30 bits) | To the next int boundary |
| count | The size of an int (4 bytes) |
| ac | 4 bits |
| (unnamed field) | 4 bits |
| clock | 1 bit |
| (padding -- 23 bits) | To the next int boundary (unnamed field) |
| flag | 1 bit |
| (padding -- 31 bits) | To the next int boundary |
kitchen.light = 1;When you assign to a bit field a value that is out of its range, the bit pattern is preserved and the appropriate bits are assigned. The following expression sets the toaster field of the kitchen structure to 0 because only the least significant bit is assigned to the toaster field:
kitchen.toaster = 2;
Reference Links:
http://publib.boulder.ibm.com/infocenter/macxhelp/v6v81/
index.jsp?topic=%2Fcom.ibm.vacpp6m.doc%2Flanguage%2Fref%2Fclrc03defbitf.htm
http://c-faq.com/struct/bitfields.html
