\documentclass[11pt,twoside]{article}\makeatletter

\IfFileExists{xcolor.sty}%
  {\RequirePackage{xcolor}}%
  {\RequirePackage{color}}
\usepackage{colortbl}
\usepackage{wrapfig}
\usepackage{ifxetex}
\ifxetex
  \usepackage{fontspec}
  \usepackage{xunicode}
  \catcode`⃥=\active \def⃥{\textbackslash}
  \catcode`❴=\active \def❴{\{}
  \catcode`❵=\active \def❵{\}}
  \def\textJapanese{\fontspec{Noto Sans CJK JP}}
  \def\textChinese{\fontspec{Noto Sans CJK SC}}
  \def\textKorean{\fontspec{Noto Sans CJK KR}}
  \setmonofont{DejaVu Sans Mono}
  
\else
  \IfFileExists{utf8x.def}%
   {\usepackage[utf8x]{inputenc}
      \PrerenderUnicode{–}
    }%
   {\usepackage[utf8]{inputenc}}
  \usepackage[english]{babel}
  \usepackage[T1]{fontenc}
  \usepackage{float}
  \usepackage[]{ucs}
  \uc@dclc{8421}{default}{\textbackslash }
  \uc@dclc{10100}{default}{\{}
  \uc@dclc{10101}{default}{\}}
  \uc@dclc{8491}{default}{\AA{}}
  \uc@dclc{8239}{default}{\,}
  \uc@dclc{20154}{default}{ }
  \uc@dclc{10148}{default}{>}
  \def\textschwa{\rotatebox{-90}{e}}
  \def\textJapanese{}
  \def\textChinese{}
  \IfFileExists{tipa.sty}{\usepackage{tipa}}{}
\fi
\def\exampleFont{\ttfamily\small}
\DeclareTextSymbol{\textpi}{OML}{25}
\usepackage{relsize}
\RequirePackage{array}
\def\@testpach{\@chclass
 \ifnum \@lastchclass=6 \@ne \@chnum \@ne \else
  \ifnum \@lastchclass=7 5 \else
   \ifnum \@lastchclass=8 \tw@ \else
    \ifnum \@lastchclass=9 \thr@@
   \else \z@
   \ifnum \@lastchclass = 10 \else
   \edef\@nextchar{\expandafter\string\@nextchar}%
   \@chnum
   \if \@nextchar c\z@ \else
    \if \@nextchar l\@ne \else
     \if \@nextchar r\tw@ \else
   \z@ \@chclass
   \if\@nextchar |\@ne \else
    \if \@nextchar !6 \else
     \if \@nextchar @7 \else
      \if \@nextchar (8 \else
       \if \@nextchar )9 \else
  10
  \@chnum
  \if \@nextchar m\thr@@\else
   \if \@nextchar p4 \else
    \if \@nextchar b5 \else
   \z@ \@chclass \z@ \@preamerr \z@ \fi \fi \fi \fi
   \fi \fi  \fi  \fi  \fi  \fi  \fi \fi \fi \fi \fi \fi}
\gdef\arraybackslash{\let\\=\@arraycr}
\def\@textsubscript#1{{\m@th\ensuremath{_{\mbox{\fontsize\sf@size\z@#1}}}}}
\def\Panel#1#2#3#4{\multicolumn{#3}{){\columncolor{#2}}#4}{#1}}
\def\abbr{}
\def\corr{}
\def\expan{}
\def\gap{}
\def\orig{}
\def\reg{}
\def\ref{}
\def\sic{}
\def\persName{}\def\name{}
\def\placeName{}
\def\orgName{}
\def\textcal#1{{\fontspec{Lucida Calligraphy}#1}}
\def\textgothic#1{{\fontspec{Lucida Blackletter}#1}}
\def\textlarge#1{{\large #1}}
\def\textoverbar#1{\ensuremath{\overline{#1}}}
\def\textquoted#1{‘#1’}
\def\textsmall#1{{\small #1}}
\def\textsubscript#1{\@textsubscript{\selectfont#1}}
\def\textxi{\ensuremath{\xi}}
\def\titlem{\itshape}
\newenvironment{biblfree}{}{\ifvmode\par\fi }
\newenvironment{bibl}{}{}
\newenvironment{byline}{\vskip6pt\itshape\fontsize{16pt}{18pt}\selectfont}{\par }
\newenvironment{citbibl}{}{\ifvmode\par\fi }
\newenvironment{docAuthor}{\ifvmode\vskip4pt\fontsize{16pt}{18pt}\selectfont\fi\itshape}{\ifvmode\par\fi }
\newenvironment{docDate}{}{\ifvmode\par\fi }
\newenvironment{docImprint}{\vskip 6pt}{\ifvmode\par\fi }
\newenvironment{docTitle}{\vskip6pt\bfseries\fontsize{22pt}{25pt}\selectfont}{\par }
\newenvironment{msHead}{\vskip 6pt}{\par}
\newenvironment{msItem}{\vskip 6pt}{\par}
\newenvironment{rubric}{}{}
\newenvironment{titlePart}{}{\par }

\newcolumntype{L}[1]{){\raggedright\arraybackslash}p{#1}}
\newcolumntype{C}[1]{){\centering\arraybackslash}p{#1}}
\newcolumntype{R}[1]{){\raggedleft\arraybackslash}p{#1}}
\newcolumntype{P}[1]{){\arraybackslash}p{#1}}
\newcolumntype{B}[1]{){\arraybackslash}b{#1}}
\newcolumntype{M}[1]{){\arraybackslash}m{#1}}
\definecolor{label}{gray}{0.75}
\def\unusedattribute#1{\sout{\textcolor{label}{#1}}}
\DeclareRobustCommand*{\xref}{\hyper@normalise\xref@}
\def\xref@#1#2{\hyper@linkurl{#2}{#1}}
\begingroup
\catcode`\_=\active
\gdef_#1{\ensuremath{\sb{\mathrm{#1}}}}
\endgroup
\mathcode`\_=\string"8000
\catcode`\_=12\relax

\usepackage[a4paper,twoside,lmargin=1in,rmargin=1in,tmargin=1in,bmargin=1in,marginparwidth=0.75in]{geometry}
\usepackage{framed}

\definecolor{shadecolor}{gray}{0.95}
\usepackage{longtable}
\usepackage[normalem]{ulem}
\usepackage{fancyvrb}
\usepackage{fancyhdr}
\usepackage{graphicx}
\usepackage{marginnote}

\renewcommand{\@cite}[1]{#1}


\renewcommand*{\marginfont}{\itshape\footnotesize}

\def\Gin@extensions{.pdf,.png,.jpg,.mps,.tif}

  \pagestyle{fancy}

\usepackage[pdftitle={Architectural principles support the continuous multimedia applications},
 pdfauthor={}]{hyperref}
\hyperbaseurl{}

	 \paperwidth210mm
	 \paperheight297mm
              
\def\@pnumwidth{1.55em}
\def\@tocrmarg {2.55em}
\def\@dotsep{4.5}
\setcounter{tocdepth}{3}
\clubpenalty=8000
\emergencystretch 3em
\hbadness=4000
\hyphenpenalty=400
\pretolerance=750
\tolerance=2000
\vbadness=4000
\widowpenalty=10000

\renewcommand\section{\@startsection {section}{1}{\z@}%
     {-1.75ex \@plus -0.5ex \@minus -.2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\Large\bfseries}}
\renewcommand\subsection{\@startsection{subsection}{2}{\z@}%
     {-1.75ex\@plus -0.5ex \@minus- .2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\Large}}
\renewcommand\subsubsection{\@startsection{subsubsection}{3}{\z@}%
     {-1.5ex\@plus -0.35ex \@minus -.2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\large}}
\renewcommand\paragraph{\@startsection{paragraph}{4}{\z@}%
     {-1ex \@plus-0.35ex \@minus -0.2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\normalsize}}
\renewcommand\subparagraph{\@startsection{subparagraph}{5}{\parindent}%
     {1.5ex \@plus1ex \@minus .2ex}%
     {-1em}%
     {\reset@font\normalsize\bfseries}}


\def\l@section#1#2{\addpenalty{\@secpenalty} \addvspace{1.0em plus 1pt}
 \@tempdima 1.5em \begingroup
 \parindent \z@ \rightskip \@pnumwidth 
 \parfillskip -\@pnumwidth 
 \bfseries \leavevmode #1\hfil \hbox to\@pnumwidth{\hss #2}\par
 \endgroup}
\def\l@subsection{\@dottedtocline{2}{1.5em}{2.3em}}
\def\l@subsubsection{\@dottedtocline{3}{3.8em}{3.2em}}
\def\l@paragraph{\@dottedtocline{4}{7.0em}{4.1em}}
\def\l@subparagraph{\@dottedtocline{5}{10em}{5em}}
\@ifundefined{c@section}{\newcounter{section}}{}
\@ifundefined{c@chapter}{\newcounter{chapter}}{}
\newif\if@mainmatter 
\@mainmattertrue
\def\chaptername{Chapter}
\def\frontmatter{%
  \pagenumbering{roman}
  \def\thechapter{\@roman\c@chapter}
  \def\theHchapter{\roman{chapter}}
  \def\thesection{\@roman\c@section}
  \def\theHsection{\roman{section}}
  \def\@chapapp{}%
}
\def\mainmatter{%
  \cleardoublepage
  \def\thechapter{\@arabic\c@chapter}
  \setcounter{chapter}{0}
  \setcounter{section}{0}
  \pagenumbering{arabic}
  \setcounter{secnumdepth}{6}
  \def\@chapapp{\chaptername}%
  \def\theHchapter{\arabic{chapter}}
  \def\thesection{\@arabic\c@section}
  \def\theHsection{\arabic{section}}
}
\def\backmatter{%
  \cleardoublepage
  \setcounter{chapter}{0}
  \setcounter{section}{0}
  \setcounter{secnumdepth}{2}
  \def\@chapapp{\appendixname}%
  \def\thechapter{\@Alph\c@chapter}
  \def\theHchapter{\Alph{chapter}}
  \appendix
}
\newenvironment{bibitemlist}[1]{%
   \list{\@biblabel{\@arabic\c@enumiv}}%
       {\settowidth\labelwidth{\@biblabel{#1}}%
        \leftmargin\labelwidth
        \advance\leftmargin\labelsep
        \@openbib@code
        \usecounter{enumiv}%
        \let\p@enumiv\@empty
        \renewcommand\theenumiv{\@arabic\c@enumiv}%
	}%
  \sloppy
  \clubpenalty4000
  \@clubpenalty \clubpenalty
  \widowpenalty4000%
  \sfcode`\.\@m}%
  {\def\@noitemerr
    {\@latex@warning{Empty `bibitemlist' environment}}%
    \endlist}

\def\tableofcontents{\section*{\contentsname}\@starttoc{toc}}
\parskip0pt
\parindent1em
\def\Panel#1#2#3#4{\multicolumn{#3}{){\columncolor{#2}}#4}{#1}}
\newenvironment{reflist}{%
  \begin{raggedright}\begin{list}{}
  {%
   \setlength{\topsep}{0pt}%
   \setlength{\rightmargin}{0.25in}%
   \setlength{\itemsep}{0pt}%
   \setlength{\itemindent}{0pt}%
   \setlength{\parskip}{0pt}%
   \setlength{\parsep}{2pt}%
   \def\makelabel##1{\itshape ##1}}%
  }
  {\end{list}\end{raggedright}}
\newenvironment{sansreflist}{%
  \begin{raggedright}\begin{list}{}
  {%
   \setlength{\topsep}{0pt}%
   \setlength{\rightmargin}{0.25in}%
   \setlength{\itemindent}{0pt}%
   \setlength{\parskip}{0pt}%
   \setlength{\itemsep}{0pt}%
   \setlength{\parsep}{2pt}%
   \def\makelabel##1{\upshape ##1}}%
  }
  {\end{list}\end{raggedright}}
\newenvironment{specHead}[2]%
 {\vspace{20pt}\hrule\vspace{10pt}%
  \phantomsection\label{#1}\markright{#2}%

  \pdfbookmark[2]{#2}{#1}%
  \hspace{-0.75in}{\bfseries\fontsize{16pt}{18pt}\selectfont#2}%
  }{}
      \def\TheFullDate{2012-01 2012-05-15 (revised: January 2012 15 May 2012)}
\def\TheID{\makeatother }
\def\TheDate{2012-01 2012-05-15}
\title{Architectural principles support the continuous multimedia applications}
\author{}\makeatletter 
\makeatletter
\newcommand*{\cleartoleftpage}{%
  \clearpage
    \if@twoside
    \ifodd\c@page
      \hbox{}\newpage
      \if@twocolumn
        \hbox{}\newpage
      \fi
    \fi
  \fi
}
\makeatother
\makeatletter
\thispagestyle{empty}
\markright{\@title}\markboth{\@title}{\@author}
\renewcommand\small{\@setfontsize\small{9pt}{11pt}\abovedisplayskip 8.5\p@ plus3\p@ minus4\p@
\belowdisplayskip \abovedisplayskip
\abovedisplayshortskip \z@ plus2\p@
\belowdisplayshortskip 4\p@ plus2\p@ minus2\p@
\def\@listi{\leftmargin\leftmargini
               \topsep 2\p@ plus1\p@ minus1\p@
               \parsep 2\p@ plus\p@ minus\p@
               \itemsep 1pt}
}
\makeatother
\fvset{frame=single,numberblanklines=false,xleftmargin=5mm,xrightmargin=5mm}
\fancyhf{} 
\setlength{\headheight}{14pt}
\fancyhead[LE]{\bfseries\leftmark} 
\fancyhead[RO]{\bfseries\rightmark} 
\fancyfoot[RO]{}
\fancyfoot[CO]{\thepage}
\fancyfoot[LO]{\TheID}
\fancyfoot[LE]{}
\fancyfoot[CE]{\thepage}
\fancyfoot[RE]{\TheID}
\hypersetup{citebordercolor=0.75 0.75 0.75,linkbordercolor=0.75 0.75 0.75,urlbordercolor=0.75 0.75 0.75,bookmarksnumbered=true}
\fancypagestyle{plain}{\fancyhead{}\renewcommand{\headrulewidth}{0pt}}

\date{}
\usepackage{authblk}

\providecommand{\keywords}[1]
{
\footnotesize
  \textbf{\textit{Index terms---}} #1
}

\usepackage{graphicx,xcolor}
\definecolor{GJBlue}{HTML}{273B81}
\definecolor{GJLightBlue}{HTML}{0A9DD9}
\definecolor{GJMediumGrey}{HTML}{6D6E70}
\definecolor{GJLightGrey}{HTML}{929497} 

\renewenvironment{abstract}{%
   \setlength{\parindent}{0pt}\raggedright
   \textcolor{GJMediumGrey}{\rule{\textwidth}{2pt}}
   \vskip16pt
   \textcolor{GJBlue}{\large\bfseries\abstractname\space}
}{%   
   \vskip8pt
   \textcolor{GJMediumGrey}{\rule{\textwidth}{2pt}}
   \vskip16pt
}

\usepackage[absolute,overlay]{textpos}

\makeatother 
      \usepackage{lineno}
      \linenumbers
      
\begin{document}

             \author[1]{Dr.L.V.Reddy  }

             \author[2]{  J.Durga}

             \affil[1]{  Department of. CSE, SVEC,A.Rangampeta}

\renewcommand\Authands{ and }

\date{\small \em Received: 14 April 2012 Accepted: 2 May 2012 Published: 15 May 2012}

\maketitle


\begin{abstract}
        


In this paper we discuss some of the architectural principles which are useful to support the continuous media applications in a microkernel environment. In particular, we discuss i) the principle of upcall-driven application structuring whereby communications events are system rather than application initiated, ii) the principle of split-level system structuring whereby, key system .functions are carried out co-operatively between kernel and user level components and iii) the principle of decoupling of control transfer and data transfer. Under these general headings a number of particular mechanisms and techniques are discussed.GJCST Classification: H.5.1 Architectural principles support the continuous multimedia applicationsStrictly as per the compliance and regulations of:

\end{abstract}


\keywords{}

\begin{textblock*}{18cm}(1cm,1cm) % {block width} (coords) 
\textcolor{GJBlue}{\LARGE Global Journals \LaTeX\ JournalKaleidoscope\texttrademark}
\end{textblock*}

\begin{textblock*}{18cm}(1.4cm,1.5cm) % {block width} (coords) 
\textcolor{GJBlue}{\footnotesize \\ Artificial Intelligence formulated this projection for compatibility purposes from the original article published at Global Journals. However, this technology is currently in beta. \emph{Therefore, kindly ignore odd layouts, missed formulae, text, tables, or figures.}}
\end{textblock*}


\let\tabcellsep& 	 	 		 
\section[{INTRODUCTION}]{INTRODUCTION}\par
e are interested in both communications and processing support for distributed reallime/multimedia applications in end systems, and believe that such applications require thread-tothread realtime support according to user supplied quality of service (QoS) parameters. Such support, depending on the level of QoS commitment required, may require dedicated, per-connection, resource allocation the CPU scheduler, virtual memory system and communication system. It may also require ongoing dynamic QoS management in all these areas \hyperref[b0]{[1]}. Another important requirement we have imposed on ourselves is to support standard UNIX applications on the same machine as our real-time/ multimedia support infrastructure; we do not want to build a specialist realtime system that is isolated from the standard application environment. In our paper the prime consideration is the efficiency. In particular in minimizing system imposed overheads by reducing the cost and number of system calls, context switches and copy operation.\par
In this paper is structured as three main sections, each of which describes a key architectural principle of our design. The three principles are: i) up call driven application structuring whereby communications events are system rather than application initiated, ii) split-level system structuring whereby key system functions are carried out cooperatively between kernel and user level components and iii) decoupling of control transfer and data transfer whereby the transfer of control is carried out asynchronously with respect to the transfer of data. 
\section[{II.}]{II.} 
\section[{UPCALL-DRIVEN APPLICATION STRUCTURING}]{UPCALL-DRIVEN APPLICATION STRUCTURING}\par
In conventional designs, system APIs are mostly passive and applications are mostly active. For example, when an application needs to send or receive data, it typically invokes a system call such send() or recv(). It also provides the buffer from/to which data is to be sent/received. In contrast, our continuous media API is structured so that the system infrastructure is active and applications are passive. Application programmers attach rthandlers, which are C functions containing application code to process the real-time media, to rtports, which are globally unique units of addressing. Then, programmers establish connections with a given QoS between rtports. At connect time, the system, rather than the application, allocates buffers for connections ,and provides the thread on which the rthandlers will be executed. At data transfer time, the system decides to upcall the application to obtain/ deliver data at instants determined by the QoS specification (in terms of rate, jitter, delay etc.) provided by the application at connect time. When an application rthandler is upcalled, the address of the associated rtport's buffer is passed as an argument so that application code in the rthandler can access the buffer. Source rthandlers are expected to fill buffers with data to be sent, and sink rthandlers to use the data as provided.\par
In conventional designs, systems API are mostly passive and applications are mostly active. For example, when an applications needs to send or receive data, it typically invokes a system call such as send() or recv(). It also provides the buffer from/ to which data is to be sent/received. In contrast, the continuous media API is structured so that the system infrastructure is active and applications are passive.\par
There are three major benefits of style of an application/system interaction in our context. First, it relieves the application of the burden of explicitly creating threads and allocating buffers. Second, the system, rather than the application, can choose the timing of application code execution, and thus can optimally monitor and manage the Quality of Service (QOS) of the connection, including the execution of application code, to provide the required thread-tothread QOS support. Third, the structuring of the API with the API rthandlers is a natural and effective model considerably simplified when programmers can structure applications to react to events and delegate to the system the responsibility for initiating communication events. The programmer is still ultimately in control of event initiation but this control is expressed declaratively through the provision of QOS parameters at connect time and need not be explicitly programmed in a procedural style \hyperref[b1]{[2]}.\par
Along with these benefits, an efficiency gain potentially results from upcall-driven application structuring, because a single thread ca be used for both protocol and application processing. In conventional systems, application interface with communications by performing system calls which block and reschedule if the communications system is not ready to send or if data has not yet arrived. With infrastructure initiated communication, on the other hand, it is not necessary for the application and communications system to wait for each other, and thus no context switch is incurred, as the communication system always initiates the exchange and the application code is always be ready to run. 
\section[{III. SPLIT-LEVEL SYSTEM STRUCTURING}]{III. SPLIT-LEVEL SYSTEM STRUCTURING}\par
The distributed multimedia applications will require high degree of internal concurrency. For example, it is likely that each media stream will require at least one thread of execution and it is also likely that applications will be structured as pipelines of processing stages on streams of media. Split-level structuring is used to maintain the merits of user space management while mitigating its demerits.\par
IV. 
\section[{SPLIT LEVEL SCHEDULING}]{SPLIT LEVEL SCHEDULING}\par
The above merits and demerits are particularly evident in the case of CPU resource management through user level threads. Here the benefits are cheap user level concurrency and the drawback is that the relative urgencies of threads in different address spaces are not visible to the kernel scheduler.\par
In split level scheduling, a small number of virtual processors (VPs) execute user threads in each address space. The split level scheduling schemes maintains the invariant that \hyperref[b4]{[5]}:\par
? Each user level scheduler (ULS) always runs its most urgent user thread, and ? The kernel level scheduler (KLS) always runs the VP supporting the globally most urgent user thread.\par
Split level scheduling allows many contexts switches to take place cheaply in the same address space but also ensures that the relative urgencies of threads across the whole machine are appropriately taken into account.\par
V. 
\section[{SPLIT LEVEL COMMUNICATION}]{SPLIT LEVEL COMMUNICATION}\par
The strategy of split level communication structuring is a leave the kernel responsible for multiplexing and demultiplexing network packets to application address spaces, but the application address spaces perform transport level processing. In this way, transport protocol processing can automatically take advantages of the split level scheduling infrastructure and thus exploit cheap user level context switches.\par
Split level communication structuring also allows meaningful deadlines to be placed on (transport level) protocol processing activities, as the ultimate deadline of the final packet delivery is easily available in the application context. Thus, the scheduling of protocol processing need not be performed 'blind' as it is in typical kernel implementation. Another advantage is that multiple transport protocols can easily be dynamically configured in and out of applications according to their particular requirements. This is important in a multimedia context where different protocols may be appropriate for different media types. 
\section[{VI. SPLIT LEVEL BUFFER MANAGEMENT}]{VI. SPLIT LEVEL BUFFER MANAGEMENT}\par
The strategy of split level buffer management is for the kernel level manager to 'loan' physical, locked, buffers to per-address space managers, but to reserve the rights to reclaim the buffers if memory is urgently required or to retain the buffer longer than it has agreed to. The policy adopted in the design level is that the application is allowed to keep buffer for at least the normal duration of transport protocol processing time plus rthandlers execution time. If the period has elapsed and the application space has not returned ownership of the buffer to the kernel, the kernel may reclaim the buffer.\par
The semantic of 'reclaiming' locked buffers is to convert locked memory into standard swappable virtual memory. In this way, applications do not lose their data although they do lose guaranteed access latency to that data as the memory region is subject to being paged out. If the kernel does not need to reclaim buffers at the end of an rthandler execution, the user space manager may reuse buffers for other connections. 
\section[{VII. DECOUPLING OF CONTROL TRANSFER AND DATA TRANSFER}]{VII. DECOUPLING OF CONTROL TRANSFER AND DATA TRANSFER}\par
In traditional systems, the transfer of control and the transfer of data are usually tightly coupled. For example, the execution of a UNIX system calls passes data to the kernel and simultaneously transfers control to the kernel. 
\section[{VIII.}]{VIII.} 
\section[{DIRECT CONNECTIONS}]{DIRECT CONNECTIONS}\par
In distributed multimedia applications it is often required to receive continuous media data from the managed by kernel level code). The application may or may not require keeping track of the transfer of individual buffers of data for synchronization purposes. The opposite scenario, where data from a local device is to be put directly onto the network, is equally common. In conventional operating system, the only way to achieve such a data flow is to route the data through an intermediate user process. But it involves significant perbuffer overheads \hyperref[b1]{[2]}.\par
In a direct connection, data that is to be passed directly between the network and a local device does not pass into user space at all; it is processed entirely within kernel space. When a direction connection is established, the infrastructure pre-maps the buffer associated with the connection into the output device's memory. Then, the data can be directly copied off the network card on to the device without leaving kernel space. The fragmentation/re-assembly functions of the in-kernel transport protocol.\par
If the user application does not need to synchronize with the delivery of buffers, no further overhead is incurred. However, if it is required to synchronize, the application can attach an rthandler to the rtport. This is up called on each buffer transfer with the usual rthandler semantic. The only difference in the API between this case and the normal case is that buffer pointer passed as an argument to the rthandler upcall will be a null pointer as the application context will not have the rights to directly access the kernel managed buffer. 
\section[{IX.}]{IX.} 
\section[{ASYNCHRONOUS SYSTEM CALLS}]{ASYNCHRONOUS SYSTEM CALLS}\par
For continuous media connections asynchronous system calls exploit the predictable periodicity of the transfer of control and data between application address spaces and the kernel. To issue an asynchronous system call (e.g. an asynchronous version of send()), user level library code:\par
? Places an operation identifier and parameters in the shared KLS/ULS memory bulletin board area and then ? Sets an 'operation request' bit, also in the bulletin board area.\par
The KLS, when it runs at the next system clock tick, notices that an operation bit is consequently passes the user's parameters to a kernel server thread which carries out the system call on behalf of the ULS. This avoids a special domain crossing for the system call at the expense a bitmap on each clock interrupt.\par
X. 
\section[{ASYNCHRONOUS SOFTWARE INTERRUPTS}]{ASYNCHRONOUS SOFTWARE INTERRUPTS}\par
The implementation of software interrupts is similar to that of asynchronous system calls and similarly avoids a special domain crossing. The mechanism for kernel to VP control transfer is as follows:\par
? The KLS places an event identifier and parameters in the KLS/ULS bulletin board area ? The KLS alters the program counter field of the target VP's context structure points to a standard entry point in the ULS.\par
Thus, when the VP is next scheduled, the VP immediately enters its ULS, which picks up the event identifier and parameters, and schedules a user thread to deal with event. Asynchronous software interrupts are also provided as a service accessible from user level code. This service enables library code in one address space to cheaply notify an event to another address space on the same machine. The service also allows the sender to name a pre-existing memory segment shared between the sender and receiver address spaces so that data can be optionally transferred in the same call.\par
XI. 
\section[{USER LEVEL PIPELINES}]{USER LEVEL PIPELINES}\par
The API for pipelines of processing stages is very similar to the connection abstraction. But rather than passing a pair of rtports as arguments to the connect() primitives, we pass a list of rtports. In the case of pipelines, the delay QOS parameter applies end-toend over the entire chain of rtports.\par
Intermediate processing stages in pipelines are also realized in a similar way to that described above: When data arrives at an intermediate processing stage, the rthandler returns, it is assumed that the rthandler's application code has performed some appropriate processing on the buffer whose address was passed up to it, and the data can be passed on to the next page.\par
As the various stages of a pipeline form part of the same application, it is typically the case that pipelines are implemented in a single address space. The data transfer mechanism in this case is as follows: When an rthandler implementing one stage of a pipeline returns, having operated on a buffer, the next stage in the pipeline is simply passed the address of the same buffer. Meanwhile, the first stage sets of work on a second buffer; and so on. At the end of the pipeline, when buffers are finished with, they are returned to a user level pool from which that can be reused by the first pipeline stage. With this implementation, intra address space pipelines incur only user level control transfers between the threads dedicated to each pipeline stage, and zero copy operations between stages. The API is the identical regardless of whether intra-address space, inter-address space or inter-machine connections or January 2012 pipelines are used. Inter-address space communication on the same machine uses buffers that are statically mapped into both the source and sink address spaces for data transfer, and use asynchronous software interrupts. 
\section[{XII.}]{XII.} 
\section[{PROPOSED SCENARIO}]{PROPOSED SCENARIO}\par
The integrated use of the principles and techniques described above, the scenario is illustrated in figure \hyperref[fig_0]{1}, involves the transfer of compressed video from a frame grabber card on a source machine to a decompress/display application on a sink machine. In figure \hyperref[fig_0]{1}, the large ovals represent user address spaces with library code below the horizontal line and application code above. The rectangles represent kernel space with the enclosed shaded regions representing devices.The send side features a direct connection, involves the video capture device and the network interface, which avoids the need for data to pass into user space. It also features the (optional) use of an rthandler to allow the sender, which is structured as an upcall-driven application, to monitor and synchronize with the progress of the connection.\par
On the receive side, the split level buffer management system allocates a physical buffer from the kernel buffer pool to hold incoming network packets associated with the connection. This buffer is statically mapped into both kernel space and the application address space.In the split level communication system, when a complete network level packet has been received, the application address space's ULS is notified via the conditional deadline mechanism and initiates transport level processing.\par
This may involve the receipt of further network packets to build a complete user level buffer.When a complete user buffer has been built, and the receiving thread has the globally earliest deadline, the ULS runs a thread which upcalls the application's rthandler with the address of the buffer as a parameter. The receive side features a user level pipeline which involves one user thread performing decompressed and another displaying uncompressed video in a window. The display is achieved by means of asynchronous system calls to display device. Context switches between the two pipeline threads are achieved at user level costs and the transmission of data from the decompressor to the displayer does not involve data copying. 
\section[{XIII.}]{XIII.} 
\section[{CONCLUSIONS}]{CONCLUSIONS}\par
We discussed three architectural principles useful for the support of distributed real-time multimedia application in operating system. Firstly we contended that the principles of upcall-driven application structuring leads to well structural real-time applications, relieves applications of the burden of explicit thread creation and buffer allocation, and leads to potential efficiency gains because of reduced context switches.\par
Secondly we argued for the principles of splitlevel system structuring. We suggested that it can improve efficiency by exploiting application specific knowledge (e.g. scheduling deadline or buffer requirements) in a local, user level, context where application/manager interact6ion is cheap, while relying on a kernel level manager to 'bias' resources to application address spaces of the basis of their relative needs. Active co-operation of management information between user and kernel level managers is key, but as long as an asynchronous style of communication between managers is acceptable, this can be achieved cheaply by means of a shared memory 'bulletin board'.\par
Finally we discussed the three principles working together in this paper. They are capable of exploited in a range of operating system environments. Similarly many of individual techniques can be useful in a stand alone fashion. When it can be compared with the distributed level, the principles which we have discussed validated in terms of direct performance measurements. \begin{figure}[htbp]
\noindent\textbf{1}\includegraphics[]{image-2.png}
\caption{\label{fig_0}Figure 1 :}\end{figure}
 			\footnote{© 2012 Global Journals Inc. (US) Global Journal of Computer Science and Technology Volume XII Issue II Version I} 			\footnote{© 2012 Global Journals Inc. (US)} 			\footnote{January 2012© 2012 Global Journals Inc. (US)This page is intentionally left blank} 		 		\backmatter  			  				\begin{bibitemlist}{1}
\bibitem[Black ()]{b0}\label{b0} 	 		‘An Asymmetric Stream Communication System’.  		 			A P Black 		.  	 	 		\textit{Proceedings of 9th ACM Symposium in Operating System Principles'},  				 (9th ACM Symposium in Operating System Principles')  		1983. p. .  	 
\bibitem[Coulson and Blair ()]{b2}\label{b2} 	 		‘Architectural Principles and Techniques for Distributed Multimedia Application Support in Operating Systems’.  		 			Geoff Coulson 		,  		 			Gordon Blair 		.  	 	 		\textit{ACM SIGOPS Operating Systems Review}  		1995. 29  (4)  p. .  	 
\bibitem[Thekkath and Nguyen ()]{b7}\label{b7} 	 		‘Implementing network protocols at user level’.  		 			C A Thekkath 		,  		 			T D Nguyen 		.  	 	 		\textit{Proceedings on Communications architectures, protocols and applications},  				 (on Communications architectures, protocols and applications)  		1993. p. 73.  	 
\bibitem[Acceta et al. ()]{b1}\label{b1} 	 		\textit{Mach: A new Kernel Foundatiuon for UNIX Development},  		 			M Acceta 		,  		 			A Tevanian 		,  		 			M Young 		.  		1986.  		 			Camegie Mellon University 		 	 	 (Technical Report) 
\bibitem[Coulson and Blair ()]{b3}\label{b3} 	 		‘Microkernel Support for Continuous Media in distributed Systems’.  		 			Geoff Coulson 		,  		 			Gordon Blair 		.  	 	 		\textit{Computer Networks and ISDN Systems}  		1994. 26  (10)  p. .  	 
\bibitem[Liu and Layland ()]{b6}\label{b6} 	 		‘Scheduling Algorithms for Multiprogramming in a Hard-Real-Time Environment’.  		 			C L Liu 		,  		 			J W Layland 		.  	 	 		\textit{Journal of the ACM}  		1973. 20  (1)  p. .  	 
\bibitem[Govindan and Anderson ()]{b5}\label{b5} 	 		‘Scheduling and IPC mechanisms for continuous media’.  		 			Ramesh Govindan 		,  		 			D P Anderson 		.  	 	 		\textit{ACM SIGOPS Operating Systems Review}  		1991. 25  (5)  p. .  	 
\bibitem[Coulson et al. ()]{b4}\label{b4} 	 		‘Supporting Continuous Media Applications in a Micro-Kernel Environment’.  		 			Geoff Coulson 		,  		 			Gordon Blair 		,  		 			P Robin 		,  		 			D Shepherd 		.  	 	 		\textit{Proceedings of the 1st International Workshop on Architecture and Protocols for High-Speed Networks},  				 (the 1st International Workshop on Architecture and Protocols for High-Speed Networks)  		1994. p. .  	 
\end{bibitemlist}
 			 		 	 
\end{document}
