In the example, since printf() was never declared, the compiler had to try to figure out what kind of function it is.

Transcription

1 Ans 1.a Dynamic lookup means that when a message is sent to an object, the method to be executed is selected dynamically, at run time, according to the implementation of the object that receives the message. In other words, the object chooses how to respond to a message. b. Dynamic method lookup is the process of determining which method definition a method signature denotes during runtime, based on the type of the object. 2. Delegation : Delegation allows the behavior of an object to be defined in terms of the behavior of another object. ie, Delegation is alternative to class inheritance. Delegation is a way of making object composition as powerful as inheritance. In delegation, two objects are involved in handling a request: a receiving object delegates operations to its delegate. this is analogous to the child classes sending requests to the parent classes. 3.Implicit and Explicit functions : An implicit function is one where the compiler assumes that the function is declared & defined elsewhere. That is, the compiler doesn't know anything more about the function than what it can figure out when you call it. int main() printf( "Hello world!\n" ); /* printf()!!?? what's that? */ return 0; In the example, since printf() was never declared, the compiler had to try to figure out what kind of function it is. It looks like void printf( const char* ); We know different, but that is close enough so it works. (Usually. A C program is automatically linked with the actual printf() function.) Now, if we want to fix the above, we can declare the function properly -- that is, explicitly: int printf( const char*,... ); /* here the function is explicitly declared */ int main() printf( "Hello world!\n" ); /* now it can be used, since the compiler knows about it */

2 return 0; However the function must still be defined somewhere. In the case of printf() it is defined in the standard library that is automatically linked with your C program. For functions you create yourself you must also declare them: void print_sum( int a, int b ); /* explicit declaration */ int main() print_sum( 27, 15 ); /* happy compiler */ return 0; void print_sum( int a, int b ) /* definition */ printf( "%d + %d = %d\n", a, b, a + b ); /* implicit function use */ Ans. Different formatting activities supported by Stream Manipulators are : 1. Setting field width. 2. Precision. 3. Unsetting format flags. 4. Flushing stream. 5. Inserting newline in the output stream and flushing the stream. 6. Inserting the null character in the output stream. 7. Skipping whitespace. 8. Setting the fill character in field. /* * File: main.cpp */ #include <iostream> #include <iomanip> using namespace std; int main() float basic, ta,da,gs; basic=10000; ta=800; da=5000; gs=basic+ta+da; cout<<"c++ "<<endl; // Inserting newline in the output stream //Set width and set fill

3 cout << setw(20) << setfill('*') << "SNJB" << setw(20) << setfill('*')<<"program"<< endl; cout.setf(ios::right); //Format flags cout<<setw(10)<<setprecision(3) <<"Basic"<<setw(10)<<basic<<endl <<setw(10)<<"ta"<<setw(10)<<ta<<endl <<setw(10)<<"da"<<setw(10)<<da<<endl <<setw(10)<<"gs"<<setw(10)<<gs<<endl; cout<<flush; //Flushing stream. return 0; OR Ans. Abstraction is the act of representing essential features without including the background details or explanations. In the computer science and software engineering domain, the abstraction principle is used to reduce complexity and allow efficient design and implementation of complex software systems. It is important due to following reasons : Class data are protected from inadvertent user-level errors, which might corrupt the state of the object. The class implementation can change without requiring the change in user-level code. Abstract Base Class : A pure virtual function is a function which does not have definition of its own. The classes which derive from this class need to provide definition for such function. A class containing at least one such pure virtual function is called as abstract base class. We cannot create objects of abstract class because it contains functions which have no definition. We can create pointers and references to an abstract class. Consider example of base class Base and derived class Derives. - The function show() is made pure virtual in the base class Base. It is overridden by the derived class. So the class Base becomes abstract base class. class Base //Abstract base class public: virtual void show() = 0; //Pure Virtual Function ; class Derived:public Base public: void show() cout << "Implementation of Virtual Function in Derived class"; ;

4 int main() Base obj; Base *b; Derived d; b = &d; b->show(); //Compile Time Error since an object of Base class which is abstract cannot be created Ans b) Type conversion is a way of, implicitly or explicitly, changing an entity of one data type into another. Implicit type conversion : known as coercion, is an automatic type conversion by the compiler. Explicit type conversion : Explicitly defined within a program (instead of being done by a compiler for implicit type conversion). Example : double d; long l; int i; double da = 3.3; if (d > i) d = i; //implicit type conversion if (i > l) l = i; if (d = = l) d *= 2; int result = (int)da; //explicit type conversion Although d, l and i belong to different data types, they will be automatically converted to equal data types each time a comparison or assignment is executed. Ans 3 a) A process control block or PCB is a data structure (a table) that holds information about a process. Every process or program that runs needs a PCB. When a user requests to run a particular program, the operating system constructs a process control block for that program. Typical information that is stored in a process control block is : The current state of the process i.e., whether it is ready, running, waiting, or whatever.

5 Unique identification of the process in order to track "which is which" information. A pointer to parent process. Similarly, a pointer to child process (if it exists). The priority of process (a part of CPU scheduling information). Pointers to locate memory of processes. A register save area. The processor it is running on. Ans b)the challenges for multicore software development are: 1) Software Decomposition : a. Choosing right way of decomposition to represent a problem or solution. b. Whether the decomposition is complete, accurate and appropriate c. Selecting appropriate model of problem and solution. 2) Task-to-Task Communication : a. Create IPC correctly b. Have proper User and File Permissions c. Properly release the resources to avoid lockups and resource leaks d. Mentioning proper data type and size 3) Concurrent Access to Data or Resources by Multiple Tasks or Agents : Manage synchronization of tasks 4) Identifying the Relationships between Concurrently Executing Tasks 5) Controlling Resource Contention Between Tasks 6) Determining Number of processes or threads needed : May be based on Application Speed, Optimality 7) Finding Reliable and Reproducible Debugging and Testing 8) Communicating a Design That Has Multiprocessing Components : Use proper representation e.g Unified Modeling Language Diagrams.

6 9) Implementing Multiprocessing and Multithreading in C++ : Use proper concurrency supporting libraries. Ans c) Overloading a function template means having different sets of function templates which differ in their parameter list. Consider following example : #include <iostream> template <class X> void func(x a) // Function code; cout << Inside f(x a) \n ; template <class X, class Y> void func(x a, Y b) //overloading function template func() // Function code; cout << Inside f(x a, Y b) \n ; int main() func(10); // calls func(x a) func(10, 20); // calls func(x a, Y b) return 0; Ans. Data Race : A data race occurs when: two or more threads concurrently accessing a location of memory one of them is a write one of them is unsynchronized // Execute this function on five threads simultaneously for ( int i = 0; i < 10000; i++ )

7 x = x + 1; Use of a synchronisation object across all the threads involved (e.g. a mutex) would address the issue. DeadLock : a) Deadlock can occur in a situation when a thread is waiting for an object lock, that is acquired by another thread and second thread is waiting for an object lock that is acquired by first thread. Since, both threads are waiting for each other to release the lock, the condition is called deadlock. b) Deadlock occurs when threads are unable to execute because they need more shared resources, and they are still holding shared resources while they wait. If two or more of these threads are both doing this, they might each want 75% of system memory to do something, but each one can only get 50%. Because they're waiting for more memory to be available, they are deadlocked. Neither one will ever make any progress unless one is killed. The synchronization mechanisms can be used to prevent deadlocks between multiple tasks by implementing the synchronization access policies as listed below and managing critical sections of tasks. 1) Semaphore and mutexes 2) Read-write locks 3) Condition variables #include <pthread.h> #include <stdio.h> #include "check.h" /* This example shows the corruption that can result if no serialization is done and also shows the use of pthread_mutex_lock(). Call it with no parameters to use pthread_mutex_lock() to protect the critical section, or 1 or more parameters to show data corruption that occurs without locking. */ #define LOOPCONSTANT #define THREADS 10 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; int i,j,k,l; int uselock=1; void *threadfunc(void *parm) int loop = 0; int rc; for (loop=0; loop<loopconstant; ++loop) if (uselock) rc = pthread_mutex_lock(&mutex); checkresults("pthread_mutex_lock()\n", rc); ++i; ++j; ++k; ++l; if (uselock) rc = pthread_mutex_unlock(&mutex); checkresults("pthread_mutex_unlock()\n", rc); return NULL;

8 int main(int argc, char **argv) pthread_t threadid[threads]; int rc=0; int loop=0; pthread_attr_t pta; printf("entering testcase\n"); printf("give any number of parameters to show data corruption\n"); if (argc!= 1) printf("a parameter was specified, no serialization is being done!\n"); uselock = 0; pthread_attr_init(&pta); pthread_attr_setdetachstate(&pta, PTHREAD_CREATE_JOINABLE); printf("creating %d threads\n", THREADS); for (loop=0; loop<threads; ++loop) rc = pthread_create(&threadid[loop], &pta, threadfunc, NULL); checkresults("pthread_create()\n", rc); printf("wait for results\n"); for (loop=0; loop<threads; ++loop) rc = pthread_join(threadid[loop], NULL); checkresults("pthread_join()\n", rc); printf("cleanup and show results\n"); pthread_attr_destroy(&pta); pthread_mutex_destroy(&mutex); printf("\nusing %d threads and LOOPCONSTANT = %d\n", THREADS, LOOPCONSTANT); printf("values are: (should be %d)\n", THREADS * LOOPCONSTANT); printf(" ==>%d, %d, %d, %d\n", i, j, k, l); printf("main completed\n"); return 0; Output : Entering testcase Give any number of parameters to show data corruption Creating 10 threads Wait for results Cleanup and show results Using 10 threads and LOOPCONSTANT = Values are: (should be ) ==> , , , Main completed Output (data corruption without locking example) Entering testcase Give any number of parameters to show data corruption A parameter was specified, no serialization is being done! Creating 10 threads Wait for results Cleanup and show results

9 Using 10 threads and LOOPCONSTANT = Values are: (should be ) ==>883380, , , Main completed Ans. An exception is a problem that arises during the execution of a program. A C++ exception is a response to an exceptional circumstance that arises while a program is running, such as an attempt to divide by zero. Exceptions provide a way to transfer control from one part of a program to another. C++ exception handling is built upon three keywords: try, catch, and throw. throw: A program throws an exception when a problem shows up. This is done using a throw keyword. catch: A program catches an exception with an exception handler at the place in a program where you want to handle the problem. The catch keyword indicates the catching of an exception. try: A try block identifies a block of code for which particular exceptions will be activated. It's followed by one or more catch blocks. #include <iostream> using namespace std; double division(int a, int b) if( b == 0 ) throw "Division by zero condition!"; return (a/b); int main () int x = 50; int y = 0; double z = 0; try z = division(x, y); cout << z << endl; catch (const char* msg) cerr << msg << endl; return 0;

10 Ans. POSIX thread library defines a thread attribute object that defines behavior of a thread or group of thread and encapsulates a subset of the properties of the thread. These attributes are accessible and modifiable by the creator of the thread as listed below: Contention Scope.. Process Scope and System Scope Stack Size Stack Address Detached State Priority Scheduling Policy and parameters 1) Initialization : The function pthread_attr_init() is used to initialize object attributes to their default values. The function is prototyped by: int pthread_attr_init(pthread_attr_t *tattr); 2) Destroying Thread Attributes : The function pthread_attr_destroy() is used to remove the storage allocated during initialization. The attribute object becomes invalid. It is prototyped by : int pthread_attr_destroy(pthread_attr_t *tattr); 3) Thread's Detach State : When a thread is created detached (PTHREAD_CREATE_DETACHED), its thread ID and other resources can be reused as soon as the thread terminates. If you do not want the calling thread to wait for the thread to terminate then call the function pthread_attr_setdetachstate(). When a thread is created nondetached (PTHREAD_CREATE_JOINABLE), it is assumed that you will be waiting for it. That is, it is assumed that you will be executing a pthread_join() on the thread. Whether a thread is created detached or nondetached, the process does not exit until all threads have exited. pthread_attr_setdetachstate() is prototyped by: int pthread_attr_setdetachstate(pthread_attr_t *tattr,int detachstate); pthread_attr_setdetachstate() returns zero after completing successfully. Any other returned value indicates that an error occurred. If the following condition occurs, the function fails and returns the corresponding value. 4) Thread's Set Scope : A thread may be bound (PTHREAD_SCOPE_SYSTEM) or an unbound (PTHREAD_SCOPE_PROCESS). Both these types of types are accessible only within a given process. The function pthread_attr_setscope() to create a bound or unbound thread. It is prototyped by: int pthread_attr_setscope(pthread_attr_t *tattr,int scope); Scope takes on the value of either PTHREAD_SCOP_SYSTEM or PTHREAD_SCOPE_PROCESS. pthread_attr_setscope() returns zero after completing successfully. Any other returned value indicates that an error occurred and an appropriate value is returned. 5) Thread Scheduling Policy : The POSIX draft standard specifies scheduling policy attributes of SCHED_FIFO (first-infirst-out), SCHED_RR (round-robin), or SCHED_OTHER (an implementation-defined method). SCHED_FIFO and SCHED_RR are optional in POSIX, and only are supported for real time bound threads. Currently, only the Solaris

11 SCHED_OTHER default value is supported in pthreads.. The function is used to set the scheduling policy.it is prototyped by: int pthread_attr_setschedpolicy(pthread_attr_t *tattr, int policy); pthread_attr_setschedpolicy() returns zero after completing successfully. Any other returned value indicates that an error occurred. 6) Thread Inherited Scheduling Policy : The function pthread_attr_setinheritsched() can be used to the inherited scheduling policy of a thread. It is prototyped by: int pthread_attr_setinheritsched(pthread_attr_t *tattr, int inherit); An inherit value of PTHREAD_INHERIT_SCHED (the default) means that the scheduling policies defined in the creating thread are to be used, and any scheduling attributes defined in the pthread_create() call are to be ignored. If PTHREAD_EXPLICIT_SCHED is used, the attributes from the pthread_create() call are to be used. The function returns zero after completing successfully. Any other returned value indicates that an error occurred. 7) Set Scheduling Parameters : Scheduling parameters are defined in the sched_param structure; only priority sched_param.sched_priority is supported. This priority is an integer value the higher the value the higher a thread's proiority for scehduling. Newly created threads run with this priority. The pthread_attr_setschedparam() is used to set this stucture appropiately. It is prototyped by: int pthread_attr_setschedparam(pthread_attr_t *tattr, const struct sched_param *param); and returns zero after completing successfully. Any other returned value indicates that an error occurred. 8) Set Stack size : There are very few occasions when it is appropriate to specify a stack, its size, or both. It is difficult even for an expert to know if the right size was specified. This is because even a program compliant with ABI standards cannot determine its stack size statically. Its size is dependent on the needs of the particular runtime environment in which it executes. You can get the absolute minimum limit on stack size by calling the macro PTHREAD_STACK_MIN (defined in <pthread.h>), which returns the amount of stack space required for a thread that executes a NULL procedure. Useful threads need more than this, so be very careful when reducing the stack size. The function pthread_attr_setstacksize() is used to set this a thread's stack size, it is prototyped by: int pthread_attr_setstacksize(pthread_attr_t *tattr, int stacksize); The stacksize attribute defines the size of the stack (in bytes) that the system will allocate. The size should not be less than the system-defined minimum stack size. pthread_attr_setstacksize() returns zero after completing successfully. Any other returned value indicates that an error occurred. An example call to this function is: #include <pthread.h> void main() pthread_attr_t tattr; pthread_t tid; int ret; void *start_routine; void arg ; int stacksize; int newprio;

12 sched_param param; /* set the priority; others are unchanged */ newprio = 30; param.sched_priority = newprio; /* initialize an attribute to the default value */ ret = pthread_attr_init(&tattr); /* set the thread detach state */ ret = pthread_attr_setdetachstate(&tattr,pthread_create_detached); /* BOUND behavior */ ret = pthread_attr_setscope(&tattr, PTHREAD_SCOPE_SYSTEM); /* set the new scheduling param */ ret = pthread_attr_setschedparam (&tattr, &param); /* set the scheduling policy to SCHED_OTHER */ ret = pthread_attr_setschedpolicy(&tattr, SCHED_OTHER); /* setting a new size */ stacksize = (PTHREAD_STACK_MIN + 0x4000); ret = pthread_attr_setstacksize(&tattr, stacksize); /* setting the base address in the attribute */ ret = pthread_attr_setstackaddr(&tattr, stackbase); /*create thread with the atrribute ret = pthread_create(&tid, &tattr, start_routine, arg); pthread_exit(); Ans. Each process contain one or more threads. These are task executed and managed by operating system and are called as Software Threads. On the other hand there are processor. Nowadays it contains few cores. If processors have, for example 4 cores( physical cores ), it can process even more operations than 4 at a time, because of some magic implementations in each of the core ( like in Hyper-threading technology ). So even if processor have 4 physical cores operating system see that it has more logical cores known as Hardware Threads. Operating system recognizes how many hardware threads processor have and according to that number schedules software threads to each of them. Both of these threads if more increase the efficiency of the core. OR Ans. 1. The operating system continuously selects a single thread to run from a system wide collection of all threads that are not waiting for the completion of an I/O request or are not blocked by some other activity 2. The Pthreads standard defines a thread-scheduling interface that allows programs with real-time tasks to get involved in the process.

13 Using the Pthreads scheduling feature, you can designate how threads share the available processing power. You may decide that all threads should have equal access to all available CPUs, or you can give some threads preferential treatment. In some applications, it's beneficial to give those threads that perform important tasks an advantage over those that perform background work. For instance, in a process-control application, a thread that responds to input for special devices could be given priority over a thread that simply maintains the log. 3. The eligibility of any given thread for special scheduling treatment is determined by the settings of two threadspecific attributes: Scheduling priority A thread's scheduling priority, in relation to that of other threads, determines which thread gets preferential access to the available CPUs at any given time. Scheduling policy A thread's scheduling policy is a way of expressing how threads of the same priority run and share the available CPUs. Scheduling Priority The scheduler begins by looking at an array of priority queues, as shown in Figure 4-8. There is a queue for each scheduling priority and, at any given priority level, the threads that are assigned that priority reside. When looking for a thread to run in a processing slot, the scheduler starts with the highest priority queue and works its way down to the lower priority queues until it finds the first thread. In this illustration only three of the priority queues hold runnable threads. When running threads either involuntarily give up their processing slot(more on this later) or go from blocked to runnable, they are placed at the end of the queue for their priority. Over time, the population of the priority queues will grow and decline. Whenever a thread with a higher priority than the current running thread becomes runnable, it interrupts the running thread and replaces it in the processing slot. From the standpoint of the thread that's been replaced, this is known as an involuntary context switch. Scheduling Policy A thread's scheduling policy determines how long it runs when it moves from the head of its priority queue to a processing slot. The two main scheduling policies are SCHED_FIFO and SCHED-RR: SCHED_FIFO

14 This policy (first-in first-out) lets a thread run until it either exits or blocks. As soon as it becomes unblocked, a blocked thread that has given up its processing slot is placed at the end of its priority queue. SCHED_RR This policy (round robin) allows a thread to run for only a fixed amount of time before it must yield its processing slot to another thread of the same priority. This fixed amount of time is usually referred to as a quantum. When a thread is interrupted, it is placed at the end of its priority queue. The Pthreads standard defines an additional policy, SCHED_OTHER, and leaves its behavior up to the implementors. On most systems, selecting SCHED_OTHER will give a thread a policy that uses some sort of time sharing with priority adjustment. By default, all threads start life with the SCHED_OTHER policy. Ans. The context of a process includes : The context of a thread includes : Context Switching of thread exists due to preemption of a thread If the threads belong to same process, they share the same address space because the threads are contained in the address of the process to which they belong. Some information is however local or unique to the thread, while other are contained within various segments of the process. INFORMATION UNIQUE TO A THREAD 1. THREAD ID.assigned when thread is created 2. State and Priority 3. Processor registers 4. Stack