EmbLogic's Blog


By default, Linux builds for the same architecture the host system is running. This is called “native compiling”. An x86 system building an x86 kernel, x86-64 building x86-64, or powerpc building powerpc are all examples of native compiling.

Building different binaries than the host runs is called cross compiling. Cross compiling is hard. The build system for the Linux kernel supports cross compiling via a two step process: 1) Specify a different architecture (ARCH) during the configure, make, and install stages. 2) Supply a cross compiler (CROSS_COMPILE) which can output the correct kind of binary code. An example cross compile command line (building the “arm” architecture) looks like:

make ARCH=arm menuconfig
make ARCH=arm CROSS_COMPILE=armv5l-

To specify a different architecture than the host, either define the “ARCH” environment variable or else add “ARCH=xxx” to the make command line for each of the make config, make, and make install stages. The acceptable values for ARCH are the names of the directories in the “arch” subdirectory of the Linux kernel source code, see Architectures for details. All stages of the build must use the same ARCH value, and building a second architecture in the same source directory requires “make distclean”. (Just “make clean” isn’t sufficient, things like the include/asm symlink need to be removed and recreated.)

To specify a cross compiler prefix, define the CROSS_COMPILE environment variable (or add CROSS_COMPILE= to each make command line). Native compiler tools, which output code aimed at the environment they’re running in, usually have a simple name (“gcc”, “ld”, “strip”). Cross compilers usually add a prefix to the name of each tool, indicating the target they produce code for. To tell the Linux kernel build to use a cross compiler named “armv4l-gcc” (and corresponding “armv4l-ld” and “armv4l-strip”) specify “CROSS_COMPILE=armv4l-”. (Prefixes ending in a dash are common, and forgetting the trailing dash in CROSS_COMPILE is a common mistake.

Posted in Uncategorized | Leave a comment

Shell ,Terminal and Console


“Shell” is the term used for any program which runs others. It wraps around another program .As the name suggest “Shell” the outer covering .for example in windows(OS) windows explorer is shell.In unix circles, shell has specialized to mean a command-line shell, centered around entering the name of the application one wants to start, followed by the names of files or other objects that the application should act on, and pressing the Enter key. launching programs in the background and managing them is mostly performed by the shell.


The word terminal can also have a more traditional meaning of a device through which one interacts with a computer, typically with a keyboard and display. In General ,we can say that end point communication with the usera special-purpose computer whose only purpose is to drive a keyboard, display, mouse and occasionally other human interaction peripherals, with the actual applications running on another, more powerful computer.


The console is a special sort of terminal. Historically, the console was a single keyboard and monitor plugged into a dedicated serial console port on a computer used for direct communication at a low level with the operating system. Modern linux systems provide virtual consoles. These are accessed through key combinations (e.g. Alt+F1 or Ctrl+Alt+F1; the function keys  numbers different consoles) which are handled at low levels of the linux operating system — this means that there is no special service which needs to be installed and configured to run. Interacting with the console is also done using a shell program.


1)Input:the terminal converts keys into control sequences (e.g. Left ? \e[D). The shell converts control sequences into commands (e.g. \e[D ? backward-char).

2)Line edition, input history and completion are provided by the shell. The terminal may provide its own line edition, history and completion instead, and only send a line to the shell when it’s ready to be executed.

3Output: the shell emits instructions such as “display foo”, “switch the foreground color to green”, “move the cursor to the next line”, etc. The terminal acts on these instructions.

Posted in Uncategorized | Leave a comment

C – Struct memory allocation

Do you know how memory is allocated for structure members in C

Always, contiguous(adjacent) memory locations are used to store structure members in memory. Consider below example to understand how memory is allocated for structures.

Example program for memory allocation in C structure

#include <stdio.h>
#include <string.h>
struct student
       int id1;
       int id2;
       char a;
       char b;
       float percentage;
int main()
    int i;
    struct student record1 = {1, 2, ‘A’, ‘B’, 90.5};
    printf(“size of structure in bytes : %d\n”,
    printf(“\nAddress of id1        = %u”, &record1.id1 );
    printf(“\nAddress of id2        = %u”, &record1.id2 );
    printf(“\nAddress of a          = %u”, &record1.a );
    printf(“\nAddress of b          = %u”, &record1.b );
    printf(“\nAddress of percentage = %u”,&record1.percentage);
    return 0;


size of structure in bytes : 16Address of id1 = 675376768
Address of id2 = 675376772
Address of a = 675376776
Address of b = 675376777
Address of percentage = 675376780

           There are 5 members declared for structure in above program. In 32 bit compiler, 4 bytes of memory is occupied by int datatype. 1 byte of memory is occupied by char datatype and 4 bytes of memory is occupied by float datatype.

Please refer below table to know from where to where memory is allocated for each datatype in contiguous (adjacent) location in memory.

Datatype Memory allocation in C (32 bit compiler)
From Address To Address Total bytes         
int id1 675376768 675376771 4
int id2 675376772 675376775 4
char a 675376776 1
char b 675376777 1
Addresses 675376778 and 675376779 are left empty
(Do you know why? Please see Structure padding topic below)
float percentage 675376780 675376783 4

           The pictorial representation of above structure memory allocation is given below. This diagram will help you to understand the memory allocation concept in C very easily.

C structure members storage in memory

Posted in Uncategorized | Leave a comment

Cross Compiler

When you develop a desktop or server application, almost always the development platform (the machine that runs your compiler) and the target platform (the machine that runs your application) are the same. By “platform” I mean the combination of CPU architecture, and Operating System. The process of building executable binaries on one machine, and run them on another machine when the CPU architecture or the Operating System are different is called “cross compilation”. A special compiler is needed for doing cross compilation that is called “cross compiler“, and sometimes just “toolchain”.

For example, desktop PC application developers for Windows or Linux can build and run their binaries on the very same machine. Even developers of server applications generally have the same basic architecture and Operating System on both their development machine and server machine. The compiler used in these cases is called “native compiler”.

On the other hand, developers of an embedded Linux application that runs on a non PC architecture (like ARM, PowerPC, MIPS, etc.) tend to use a cross compiler to generate executable binaries from source code. The cross compiler must be specifically tailored for doing cross compilation from the development machine’s architecture (sometimes called “host”), to the embedded machine’s architecture (called “target”).

Note: cross compilation is only needed when generating binary executables from source code written in a compiled language, like C or C++. Programs written in interpreted language, like Perl, Python, PHP, or JavaScript, do not need a cross compiler. In most cases interpreted programs should be able run unchanged on any target. You do need, however, a suitable interpreter running on the target machine.

Posted in Uncategorized | Leave a comment

linux booting process.

booting process.

1.BIOS(Basic Input/Output System)

2.MBR(Master Boot Record)


LILO:-LInux LOader

GRUB:-GRand Unified Bootloader



6.Run Levels


i.When we power on BIOS performs a Power-On Self-Test (POST) for all of the different hardware components in the system to make sure everything is working properly

ii.Also it checks for whether the computer is being started from an off position (cold boot) or from a restart (warm boot) is
stored at this location.

iii.Retrieves information from CMOS (Complementary Metal-Oxide Semiconductor) a battery operated memory chip on the motherboard that stores time, date, and critical system information.

iv.Once BIOS sees everything is fine it will begin searching for an operating system Boot Sector on a valid master boot sector
on all available drives like hard disks,CD-ROM drive etc.

v.Once BIOS finds a valid MBR it will give the instructions to boot and executes the first 512-byte boot sector that is the first
sector (“Sector 0?) of a partitioned data storage device such as hard disk or CD-ROM etc .


i. Normally we use multi-level boot loader.Here MBR means I am referencing to DOS MBR.

ii.Afer BIOS executes a valid DOS MBR,the DOS MBR will search for a valid primary partition marked as bootable on the hard disk.

iii.If MBR finds a valid bootable primary partition then it executes the first 512-bytes of that partition which is second level MBR.

iv. In linux we have two types of the above mentioned second level MBR known as LILO and GRUB


i.LILO is a linux boot loader which is too big to fit into single sector of 512-bytes.

ii.So it is divided into two parts :an installer and a runtime module.

iii.The installer module places the runtime module on MBR.The runtime module has the info about all operating systems installed.

iv.When the runtime module is executed it selects the operating system to load and transfers the control to kernel.

v.LILO does not understand filesystems and boot images to be loaded and treats them as raw disk offsets


i.GRUB MBR consists of 446 bytes of primary bootloader code and 64 bytes of the partition table.

ii.GRUB locates all the operating systems installed and gives a GUI to select the operating system need to be loaded.

iii.Once user selects the operating system GRUB will pass control to the karnel of that operating system.
see below what is the difference between LILO and GRUB


i.Once GRUB or LILO transfers the control to Kernel,the Kernels does the following tasks

Intitialises devices and loads initrd module
mounts root filesystem


i.The kernel, once it is loaded, finds init in sbin(/sbin/init) and executes it.

ii.Hence the first process which is started in linux is init process.

iii.This init process reads /etc/inittab file and sets the path, starts swapping, checks the file systems, and so on.

iv.It runs all the boot scripts(/etc/rc.d/*,/etc/rc.boot/*)

v.starts the system on specified run level in the file /etc/inittab


i.There are 7 run levels in which the linux OS runs and different run levels serves for different purpose.The descriptions are
given below.

0 – halt
1 – Single user mode
2 – Multiuser, without NFS (The same as 3, if you don’t have networking)
3 – Full multiuser mode
4 – unused
5 – X11
6 – Reboot

ii.We can set in which runlevel we want to run our operating system by defining it on /etc/inittab file.

Now as per our setting in /etc/inittab the Operating System the operating system boots up and finishes the bootup process.

Below are given some few important differences about LILO and GRUB

LILO has no interactive command interface GRUB has interactive command interface
LILO does not support booting from a network GRUB does support booting from a network
If you change your LILO config file, you have to rewrite the LILO stage one boot loader to the MBR GRUB automatically detects any change in config file and auto loads the OS
LILO supports only linux operating system GRUB supports large number of OS

Posted in Uncategorized | Leave a comment

shell script using while loop

2 RCS file: shel4,v
3 Working file: shel4
4 head: 1.1
5 branch:
6 locks: strict
7         root: 1.1
8 access list:
9 symbolic names:
10 keyword substitution: kv
11 total revisions: 1;     selected revisions: 1
12 description:
13 program of shell script using while loop
14 used to print *
15 —————————-
16 revision 1.1    locked by: root;
17 date: 2014/04/15 12:33:54;  author: root;  state: Exp;
18 Initial revision
19 ============================================================================    =
21 RCS file: shel4,v
22 Working file: shel4
“shell” 38L, 914C                                             1,0-1         Top

Posted in Uncategorized | Leave a comment

working on shell scripting

RCS file: scripting1.sh,v
3 Working file: scripting1.sh
4 head:
5 branch:
6 locks: strict
7 access list:
8 symbolic names:
9 keyword substitution: kv
10 total revisions: 0
11 description:
12 scripting
13 printing value using “echo”
14 ============================================================================

RCS file: scripting2.sh,v
3 Working file: scripting2.sh
4 head:
5 branch:
6 locks: strict
7 access list:
8 symbolic names:
9 keyword substitution: kv
10 total revisions: 0
11 description:
12 Scripting
13 using command unset to remove the assigned value
14 ============================================================================ RCS file: scripting3.sh,v
3 Working file: scripting3.sh
4 head:
5 branch:
6 locks: strict
7 access list:
8 symbolic names:
9 keyword substitution: kv
10 total revisions: 0
11 description:
12 scripting
13 printing the words in same line using “-n”
14 ============================================================================

RCS file: scripting5.sh,v
3 Working file: scripting5.sh
4 head:
5 branch:
6 locks: strict
7 access list:
8 symbolic names:
9 keyword substitution: kv
10 total revisions: 0
11 description:
12 using else if in script
13 ============================================================================

RCS file: scripting6.sh,v
3 Working file: scripting6.sh
4 head:
5 branch:
6 locks: strict
7 access list:
8 symbolic names:
9 keyword substitution: kv
10 total revisions: 0
11 description:
12 using case in script
13 ============================================================================

RCS file: scripting8.sh,v
3 Working file: scripting8.sh
4 head:
5 branch:
6 locks: strict
7 access list:
8 symbolic names:
9 keyword substitution: kv
10 total revisions: 0
11 description:
12 using for loop in script
13 ============================================================================

RCS file: scripting11.sh,v
3 Working file: scripting11.sh
4 head:
5 branch:
6 locks: strict
7 access list:
8 symbolic names:
9 keyword substitution: kv
10 total revisions: 0
11 description:
12 using while loop and `expr` in script
13 ============================================================================

Posted in Shell Scripts | Leave a comment


shell script is powerful and easy to use programming language. They are used for doing multiple jobs at a time. In shell script memory allocation is done on interpreter in the form of byte. shell script are interpreted not complied. shell read commands from the script and search those command in the system . complier convert program into machine readable form

shell is a program that takes command typed by the user and calls operating system to run those commands. Commonly used commands in shell script are—

1. unset —-used to delete variable

2. echo——used for printing

3. read——preform the function of scanf


Posted in Uncategorized | Leave a comment

How to set static ip in Fedora

Below is the method to give your machine a static Ip for the fedora.[Next post will contain the method to provide Static ip to Raspberry Pi running raspbian]

1. First stop and disable the gnome network manager from running on boot.

#systemctl stop NetworkManager.service
#systemctl disable NetworkManager.service

2. Now start and enable the network service to run on boot.

#systemctl restart network.service
#systemctl enable network.service

Set the Static Address
1. Check which interface(s) you want to set as static.

# ifconfig
em1: flags=4163 mtu 1500
inet netmask broadcast
inet6 fe80::dad3:85ff:feae:dd4c prefixlen 64 scopeid 0×20 ether d8:d3:85:ae:dd:4c txqueuelen 1000 (Ethernet)
RX packets 929 bytes 90374 (88.2 KiB)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 1010 bytes 130252 (127.1 KiB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
device interrupt 19

lo: flags=73mtu 16436
inet netmask
inet6 ::1 prefixlen 128 scopeid 0×10
loop txqueuelen 0 (Local Loopback)
RX packets 32 bytes 3210 (3.1 KiB)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 32 bytes 3210 (3.1 KiB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0

2. Next edit the config file for the required interface.

vim /etc/sysconfig/network-scripts/ifcfg-em1

3. Edit the config file to look similar to the following.

Change the BOOTPROTO from “dhcp” to “static”. Also adding IPADDR, NETMASK, BROADCAST and NETWORK variables and make sure ONBOOT is set to yes.


Exit the editor by pressing ‘:wq’ and enter.

4. Restart the network service to apply the settings.

systemctl restart network.service

source : https://fedoraproject.org/

Posted in Project 00: Linux System / Network Administration | Leave a comment


A Unix shell is a command-line interpreter or shell that provides a traditional user interface for the Unix operating system and for Unix-like systems. Users direct the operation of the computer by entering commands as text for a command line interpreter to execute, or by creating text scripts of one or more such commands. Users typically interact with a Unix shell using a terminal emulator, however, direct operation via serial hardware connections, or networking session, are common for server systems.

The most influential Unix shells have been the Bourne shell and the C shell, These shells have both been used as the coding base and model for many derivative and work-alike shells with extended feature sets.

The Bourne shell, sh, was written by Stephen Bourne at AT&T as the original Unix command line interpreter; it introduced the basic features common to all the Unix shells, including piping, here documents, command substitution, variables, control structures for condition-testing and looping and filename wildcarding. The language, including the use of a reversed keyword to mark the end of a block, was influenced by ALGOL 68.[1]

The C shell, csh, was written by Bill Joy while a graduate student at University of California, Berkeley. The language, including the control structures and the expression grammar, was modeled on C. The C shell also introduced a large number of features for interactive work, including the history and editing mechanisms, aliases, directory stacks, tilde notation, cdpath, job control and path hashing.

Posted in Project 9: Embedded Linux on ARM | Leave a comment


Bash is a Unix shell written by Brian Fox for the GNU Project as a free software replacement for the Bourne shell (sh).[3][4] Released in 1989,[5] it has been distributed widely as the shell for the GNU operating system and as a default shell on Linux and Mac OS X. It has been ported to Microsoft Windows and distributed with Cygwin and MinGW, to DOS by the DJGPP project, to Novell NetWare and to Android via various terminal emulation applications.

Bash is a command processor, typically run in a text window, allowing the user to type commands which cause actions. Bash can also read commands from a file, called a script. Like all Unix shells, it supports filename wildcarding, piping, here documents, command substitution, variables and control structures for condition-testing and iteration.[6] The keywords, syntax and other basic features of the language were all copied from sh. Other features, e.g., history, were copied from csh and ksh. Bash is a POSIX shell but with a number of extensions.

The name itself is an acronym, a pun, and a description. As an acronym, it stands for Bourne-again shell, referring to its objective as a free replacement for the Bourne shell.[7] As a pun, it expressed that objective in a phrase that sounds similar to born again, a term for spiritual rebirth.[8][9] The name is also descriptive of what it did, bashing together the features of sh, csh and ksh.

Posted in Project 9: Embedded Linux on ARM | Leave a comment

Difference between Raspberry Pi, Beaglebone, Olinuxino (etc).

You will get the list of all the Soc, Microprocessors, microcontrollers (based on arm) with the key differences between them.


Posted in ARM Embedded Processors, Embedded Controllers | Leave a comment


In order to connect your Raspberry Pi and laptop, you could do it in two ways,

router based connection.
peer to peer connection.

Router Based Connection

In this type of connection it is assumed that your laptop is already in the network, lets say your ip to be and you machine has ssh support.Now in Raspberry it is important that it has ssh support as well. Connect your raspberry pi into the router using a network cable, your raspberry will now have an ip address that was provided by the dhcp server. our next step is to find out the ip address of raspberry pi. In order to get the ip address of raspberry pi we could type ifconfig and look for “inet addr: x.x.x.x” if your raspberry is connected to a monitor. else if it is headless ( without a monitor) then we could look at the ip table of your router by seeing who is connected to the network. now that we know the ip address we could do the following from host machine

$ ssh pi@

where is the ip address of Raspberry provided by dhcp server.

Peer To Peer Connection

In a peer to peer based connection the Raspberry and host machine is directly connected to each other using a network cable. In order to do this we need static ip’s at both the ends. so we need to make the following change in /etc/network/interfaces file host machine, (note: dont forget to take a backup of /etc/network/interfaces file)

$sudo vim /etc/network/interfaces

auto eth0
iface eth0 inet static

add the above shown line to the file.

do the same in Raspberry pi as well but the only difference is that the ip address should be, note that the network id 192.168.10 should remain same.

after doing this restart the network service by typing the command or by restarting the machine.

$sudo /etc/init.d/networking restart.

then do a

$ssh pi@

and now it will ask for password, provide the password. So you are now logged it to raspberry pi via ssh.




Posted in ARM Embedded Processors, Project 00: Linux System / Network Administration | Leave a comment

Hands on raspberry pi(Soc)

The Raspberry Pi is a credit-card-sized single-board computer developed in the UK by the Raspberry Pi Foundation. The Raspberry Pi is manufactured in two board configurations. The Raspberry Pi has a Broadcom BCM2835 system on a chip (SoC), which includes an ARM1176JZF-S 700 MHz processor, VideoCore IV GPU shipped with 512 megabytes of RAM. It does not include a built-in hard disk or solid-state drive, but uses an SD card for booting and persistent storage. The Foundation provides Debian and Arch Linux ARM distributions for download. Tools are available for Python as the main programming language, with support for BBC BASIC (via the RISC OS image or the Brandy Basic clone for Linux), C, Java and Perl.

Specification of Raspberry Pi (Model B)
Target price         : US$ 35
SoC                    : Broadcom BCM2835 (CPU, GPU, DSP, SDRAM, and single USB port)
CPU                    : 700 MHz ARM1176JZF-S core (ARM11 family, ARMv6 instruction set)
GPU                   : Broadcom VideoCore IV @ 250 MHz

OpenGL ES 2.0 (24 GFLOPS)

MPEG-2 and VC-1 (with license), 1080p30 h.264/MPEG-4 AVC high profile decoder and encoder

Memory (SDRAM)    : 512 MB (shared with GPU) as of 15 October 2012
USB 2.0 ports            : 1 (direct from BCM2835 chip) 2 (via the built in integrated 3-port     USB hub)
Video input               : A CSI input connector allows for the connection of a RPF designed     camera module
Video outputs           : Composite RCA (PAL and NTSC), HDMI (rev 1.3 & 1.4), raw             LCD Panels via DSI

14 HDMI resolutions from 640×350 to 1920×1200 plus various                                               PAL and NTSC standards.

Audio outputs           : 3.5 mm jack, HDMI, and, as of revision 2 boards, I²S audio(also potentially for audio input)
Onboard storage       : SD / MMC / SDIO card slot (3.3 V card power support only)
Onboard network     : 10/100 Mbit/s Ethernet (8P8C) USB adapter on the third port of the USB hub
Low-level peripherals: 8 × GPIO, UART, I²C bus, SPI bus with two chip selects, I²S audio +3.3 V, +5 V, ground
Power ratings          : 700 mA (3.5 W)
Power source          : 5 V via MicroUSB or GPIO header
Size                        : 85.60 mm × 56 mm (3.370 in × 2.205 in)
Weight                     : 45 g (1.6 oz)
Operating systems   : Arch Linux ARM, Debian GNU/Linux, Gentoo, Fedora, FreeBSD, NetBSD, Plan 9, Raspbian OS, RISC OS, Slackware Linux, OR your own compiled OS (Toolchain in project 9)




Posted in ARM Embedded Processors, Project 9: Embedded Linux on ARM | Leave a comment

IPC: Message queue

RCS file: msg.c,v
Working file: msg.c
head: 1.19
locks: strict
akshat: 1.19
access list:
symbolic names:
keyword substitution: kv
total revisions: 19;    selected revisions: 19
IPC project.
This projectb is client server based project using msg queues.
Server is reading data from 3 clients simultaneously.
Semaphore is still not used for synchronisation.
Lets proceed.
revision 1.19    locked by: akshat;
date: 2014/04/02 22:06:23;  author: akshat;  state: Exp;  lines: +6 -6
*** empty log message ***
revision 1.18
date: 2014/04/02 21:25:08;  author: akshat;  state: Exp;  lines: +2 -2
semaphore is removed.
now its working better than earlier.
revision 1.17
date: 2014/04/02 20:59:21;  author: akshat;  state: Exp;  lines: +3 -9
*** empty log message ***
revision 1.16
date: 2014/04/02 19:14:43;  author: akshat;  state: Exp;  lines: +4 -0
Sometimes it works and sometimes it dont.
revision 1.15
date: 2014/04/02 19:04:52;  author: akshat;  state: Exp;  lines: +0 -6
checking for wrong implementation of some functions.
revision 1.14
date: 2014/04/02 19:01:02;  author: akshat;  state: Exp;  lines: +11 -10
in server result found is incorrect.
revision 1.13
date: 2014/04/02 17:56:34;  author: akshat;  state: Exp;  lines: +14 -12
checking for errors.
revision 1.12
date: 2014/04/02 17:50:06;  author: akshat;  state: Exp;  lines: +5 -5
Now next step is to transmit the result from processing clients back to server.
tryng that.
revision 1.11
date: 2014/04/02 17:47:32;  author: akshat;  state: Exp;  lines: +2 -2
Both the semaphores are working.
revision 1.10
date: 2014/04/02 17:39:59;  author: akshat;  state: Exp;  lines: +12 -2
This is proper implementation using 2 msg queues.
requesting clients are sending data to server.
server is sending this data to processing cluients using single msg queue.
its working.
revision 1.9
date: 2014/04/02 17:22:06;  author: akshat;  state: Exp;  lines: +2 -6
on progress.
revision 1.8
date: 2014/04/02 17:13:27;  author: akshat;  state: Exp;  lines: +10 -5
not working properly :(
revision 1.7
date: 2014/04/02 16:47:55;  author: akshat;  state: Exp;  lines: +1 -0
Working on sending msgs from server to processing client.
revision 1.6
date: 2014/04/02 16:34:43;  author: akshat;  state: Exp;  lines: +0 -6
Semaphore is implemented on requesting clients.
its working now,
Result from server has to be passed to processing clients.
revision 1.5
date: 2014/04/02 16:15:19;  author: akshat;  state: Exp;  lines: +6 -5
semaphore implementation done.
checking for correct answers.
revision 1.4
date: 2014/04/02 15:48:50;  author: akshat;  state: Exp;  lines: +27 -2
Semaphore is used for passing the results from server to processing clients.
Synchronisation was poor otherwise.
lets see if its working.
revision 1.3
date: 2014/04/02 15:24:54;  author: akshat;  state: Exp;  lines: +13 -1
no synchronisation.
revision 1.2
date: 2014/04/02 14:49:24;  author: akshat;  state: Exp;  lines: +1 -1
Now passing the operands to processing clients.
lets see if synchronisation is required or not.
revision 1.1
date: 2014/04/02 14:48:28;  author: akshat;  state: Exp;
Initial revision

Posted in Uncategorized | Leave a comment