Let me know

Redis Cluster Client for Erlang

noreply@blogger.com (Anonymous) — Tue, 15 Aug 2017 15:45:00 +0000

Redis

Redis (Remote Dictionary Service) is an open source NoSQL database server which is licensed under BSD-license. Redis is an advanced key-value store and considered as a data structure server since keys can contain many of the foundational data types such as Strings, Lists, Sets, Sorted Sets, and Hashes. Redis works with an in-memory data set in order to reduce the overhead in accessing the non-volatile memory and thus supposed to keep the entire key space in memory during operations. When terminated
data will be purged from memory. But depending on the use case, data can be persisted either by taking a snapshot of the data and dumping it on disk periodically or by maintaining an append-only log of all operations.

Redis is supporting advanced features like Sorted Sets, and many other complex atomic operations since it is in memory, and single threaded. Redis does not use the Operating System-supplied Virtual Memory facilities and instead implements its own system called Redis Virtual Memory.
The goal of Redis Virtual Memory (VM) is to swap infrequently-accessed data from RAM to disk, without drastically changing the performance characteristics of the database while supporting data sets that are larger than main memory.

For production applications, replicating the data across multiple nodes is mandatory task and redundancy allows for recovery in case of environment failure. Since the Redis is heavily used in concurrent applications because of its performance, load distribution across multiple nodes is also an important point. With previous versions of the Redis DB, replication and data distribution over multiple nodes are handled within the application itself as described in the below diagram.

Redis Clustering

With the Redis version 3.0, Redis introduced Redis Clustering, which reduces an application headache in Redis node management by letting the application to query required data.

Please refer the Redis official document for clustering and the following image provides an abstract view of the cluster concept.

Erlang Redis Cluster Client - eredis_cluster_client

The eredis_cluster_client is an enhanced version of eredis_cluster an Erlang wrapper for eredis client which provides the ability to connect multiple clusters initiating a single eredis_cluster_client instance.
The eredis_cluster client only facilitates to access a single cluster within your application, while eredis_cluster_client implemented on the top of eredis_cluster to address this issue.

To connect multiple Redis clusters in your application, you need to start the eredis_cluster_pool supervisor, and multiple eredis_cluster_client s in your application supervisor as,

Available functions.

eredis_cluster_client Git Repo : https://github.com/Tiroshan/eredis_cluster_client

Hands on k-Nearest Neighbour Algorithm - (k-NN)

noreply@blogger.com (Anonymous) — Wed, 08 Feb 2017 10:28:00 +0000

From this post onward I am trying to explain Data mining and Machine learning algorithms which I have tried out for some industrial solutions during my professional career as a data scientist and kick off this initiative with a simple machine learning algorithm which is called as “k-Nearest Neighbour”.
The k-NN algorithm is categorized as an Instanced Based Algorithm and known as a classification or Supervised Learning Algorithm.

What is k-NN Algorithm?

As the name itself describes the methodology, it looks for k number of nearest-neighbours when it requires to predict some labels for a given unknown data point and consider the majority voting.

It does not refer a model for a prediction on unknown data, hence there is no learning requires, other than storing entire training data set. That means it makes predictions using the training data set directly and predict class label for an unknown instance by searching through the entire set for the k-most similar neighbors.

As an example let’s consider 2-D data space, that has 5 data points labeled as triangles (green) and 8 data points labeled as circles (red). Suppose that we need to find the label of an unknown data point (let’s take it as a square (blue) ) considering the distribution.

At a glance, you may able to predict it as a triangle data point.
We can predict the unknown label as follows either consider,

Consider k-nearest neighbors and get majority voting among candidates

Consider k radius circular space and get majority voting among candidates

Consider k-nearest neighbors

In this approach, the algorithm calculates the distance between given data point and each and every data point in the training set and consider k number of neighbors among them as shown in the diagram. ( consider k=5)

Consider k radius circular space

Here it considers data points which are inside a circle that has k unit radius and then consider majority voting among candidates.

Efficiency & Accuracy Improvements

Since the algorithm scans through all training elements in order to generate results, time complexity increases with the size of the data set.

Suppose we have n examples each of dimension d algorithm takes O(nd) to compute distances to all examples and takes O(ndk) time to find k closest examples. So the total time complexity of the algorithm is O(ndk).

Thus several approaches had taken to improve the efficiency as well as the accuracy of the algorithm.

Efficiency -

Reducing the number of samples

k-D tree / k-Dimensional tree -

A data structure used for organizing some number of points in a space with k dimensions. It is a binary search tree with other constraints imposed on it. K-d trees are very useful for range and nearest neighbor searches. This partition space recursively and search for Nearest Neighbour only close to the test point.

Vector Quantization

An artificial neural network algorithm that computes representatives (codebooks) for a given training set and it reduces the sample size by introducing codebook vectors as training data for the algorithm.

Reducing the dimension size

Dimensionality reduction approaches like Principal Component Analysis, Linear Discriminant Analysis etc. can be used to reduce the size of the dimension space.

Accuracy -

Use a proper distance calculation

For the demonstration purpose I have used the most popular distance measure - Euclidean distance. It calculated as follows,

Euclidean_Distance(x, xi) = sqrt( sum( (xj – xij)^2 ) )

Where,

x : new data point

xi : existing point

j : input attributes

This algorithm can be implemented using other popular distance calculation approaches like Hamming Distance , Manhattan Distance ,Minkowski Distance, Tanimoto Distance, Jaccard Index, Cosine Similarity and Kernel Methods based on the properties of the data set. If it is difficult to select the proper distance calculation with your data, you can try with different distance metrics with different k values and select the most accurate approach.

Distance weighted algorithm

Consider distance of a neighbor with a weigh the contribution of each of the k-neighbours to their distance to the given instance (x) that results from greater weight (w) when a neighbor more close to the given instance (x).

Feature weighted Algorithm

Some features (dimensions) may be much more discriminative than other features. But the Euclidean distance treats each feature as equally important and will reduce the accuracy of the predictions. So it is good to scale each feature by its importance for classification.

The sample implementation of k-Nearest Neighbor Algorithm - Git .

Note :

Since the k-NN algorithm stores the entire training data set, you may want to consider the consistency of your training data.

Hands on Pig Unit Testing

noreply@blogger.com (Anonymous) — Wed, 04 Jan 2017 18:13:00 +0000

Why Unit Testing ?

When we develop a distributed system, it is crucial to test the logic in an automated way and execute tests in the development environment (with an IDE). The productivity of our development process could kill because of this long development-test-development cycle for complex systems.

In the domain of distributed system and big data analytics we have to implement complex logic and sometimes we have to change the logic that we have implemented due various requirements and reasons. In this case, we need to assure that changes in our code will not break the entire process or entire application.

What is Pig ?

Pig is a highly used for data analysis problems and it is a scripting language which is used with Apache Hadoop. Pig is provided flexibility in data manipulation in Apache Hadoop and it works with data from many sources (including structured and unstructured data).

Behind the scene, pig scripts are translated into a series of MapReduce jobs that are run on the Apache Hadoop cluster.

You can find more details about Pig from this link.

Familiar with Pig Unit Test ?

When you are working with pig script, you need to test your Pig Latin scripts. Even after the implementation of data flows, you need to test your logic regularly when you do some changes to scripts, to UDFs or in the version of Pig and Hadoop that you are using, in order to ensure that changes do not break your code.

For unit testing of Pig scripts, there is Pig Unit library provided by Apache group. It enables running of Pig script using JUnit. Pig Unit can run in Local and MapReduce mode. By default Local mode will be used, this mode does not require a cluster. It will enable you to use your local file system as a Hadoop cluster, each time it will create a new local one. On the other hand, MapReduce mode does require Hadoop cluster and installation of HDFS. For Development testing, purpose developers can run Pig Unit in Local mode.

Official Pig Unit Test Guide: https://pig.apache.org/docs/r0.8.1/pigunit.html

The minimal required set up for Pig Unit test consists of four libraries:

Hadoop Core - needed for working with Hadoop File System (https://mvnrepository.com/artifact/org.apache.hadoop/hadoop-core)
Apache Pig Unit - core component for running tests (https://mvnrepository.com/artifact/org.apache.pig/pigunit)
Jline - needed for reading input (https://mvnrepository.com/artifact/jline/jline)
Joda Time - needed for time operations used by PigUnit (https://mvnrepository.com/artifact/joda-time/joda-time)

Maven :

Gradle :

Link to dependencies.gradle of Pig Unit Test Tutorial Project

Link to build.gradle of Pig Unit Test Tutorial Project

Here I refer my Word count project to explain the features of Pig Unit framework. Additionally, I have included a step to load some data from an HBase table and will explain how to mock external data source in Pig Unit Test (which is not explained in most of the tutorials).

NOTE: I have provided 2 shells scripts to create that HBase table on your cluster and DML for it if you really want to try it on a Hadoop Environment. You can find them from here.

My Word Count pig is like this:

First, it loads input file from an HDFS location passed from externally and extracts words while ignoring unwanted characters. Then it loads data from an HBase table (namespace and table name is provided externally) which keeps words to be filtered from HDFS data. Then it joins loaded HBase data and HDFS data. Then it groups words and gets the count of each word. Finally, it stores the result on HDFS as the path is given externally.

Let us see how we going to test this flow using Pig Unit Testing framework.

You can mock external parameters which are provided externally as a string array like,

You can use local file system files paths instead of HDFS file location when you execute Pig Unit Tests. You can provide them with relative paths.

You have to mock external data sources and for this, we can use Pig Unit override feature and it will override a line of code at the run time for a given alias.

Here Pig unit will override above Pig code by

You can verify intermediate results (units) using an external file which contains expected result or using a string array of expected results etc.

Note that Pig currently drops all STORE and DUMP commands. You have to tell PigUnit to keep the commands and execute the script like this. If you run this, Pig unit will create an output part file inside ‘/resources/output/wordcount/’ directory

Find my Pig Unit example from git and refer ‘pig unit test tutorial’ for this.

Load Dynamic & Complex Json Messages in Pig Script without a schema

noreply@blogger.com (Anonymous) — Thu, 29 Dec 2016 06:10:00 +0000

Load Complex & Dynamic JSON messages - Problem

Suppose that you have to load dynamic and complex JSON messages and have done some transformations and aggregations in your pig script. Simply you can use Pig In built JsonLoader to load JSON messages from HDFS. As an example, let’s try to load some HDFS data which stored as following Json format.

[NOTE - You need to give JSON message as a single line string as in Pig Example GIT project ]

We can load JSON data using Pig in built JsonLoder as shown below and I have Flattened data which is inside the pig bag. Then final tuple is created.

NOTE : $jsonFilePath is an external parameter - passed to script.

Yes, In pig script we can use JSONLoader which comes with Pig as a built in function for load complex JSON messages. But the problem with the JSONLoader is that the entire schema has to be specified as shown below.
What if positions of the Json message has changed without changing the format. Then Jsonloader loads data to the wrong attribute according to the given schema.
Let's look at a simple example. Here I take a simple JSON message as below.

{

“A”:”val_a”,

“B”:”val_b”

}

If we have given schema as follows,

JsonLoader assume that every data in that format and convert it to a pig data structure like,

{

“A”:”val_a”, --------------> A: chararray

“B”:”val_b” --------------> B: chararray

}

But if some data exists as below, without affecting to the format but has changed in order.

{

“B”:”val_b”,

“A”:”val_a”

}

Pig will load that messages as below since we have provided the expected schema and it will break the entire logic of the data flow.

{

“B”:”val_b”, --------------> A: chararray

“A”:”val_a” --------------> B: chararray

}

This is critical with data which has dynamic and complex Json format. But Twitter has introduced an open source library called “Elephant-Bird” which can address this drawback. This library consists many features other than loading of dynamic JSON message functionality.

How to use Elephant-bird - Solution

With the JsonLoader from elephant-bird, there is no need to specify the schema. The JsonLoader simply returns a Pig map data type and fields can be accessed using the JSON property name as shown below.

You can download Elephant Bird library from this and refer this to be more familiar with Elephant-bird.

When you are using an external library, you have to register it to Pig script using REGISTER.

NOTE: $elephantBirdLibPath - path to elephant-bird jars. (local file path)

Please refer this git project to familiar with the elephant-bird library. I have integrated Pig unit along with this project and you can run it in your local environment. (just run unit test)

Hadoop submit command if you run this on Hadoop.

Next Level Shopping Experience - Adapt NAO Humanoid Robot Features In Customer Care

noreply@blogger.com (Anonymous) — Tue, 20 Dec 2016 08:58:00 +0000

Humanoid Robot ?

Humanoid Robot is a machine which is a combination of hardware and software and it can interact with humans, but for a specific purpose or a domain since it only programmed for one specific area.

NAO is also a humanoid robot which is a product of Aldebaran Robotics and it includes many advanced features like wireless capable and programmable with abstract interfaces. It introduces specific tasks such as face recognition & detection, voice recognition & detection, voice to text translation, text to speech with some advanced gestures.

Click this to find features of NAO humanoid robot.

Integrate a Display to NAO

Here I tried to display product description with some product related attributes, views and some recommendations through a product catalog when a customer requests a product search (voice based request) from NAO. When a customer appears in front of NAO, It greats (waves hands and greet according to the time) the customer and then asks for a product search. When that client performs a voice based product search, NAO extracts the product name, product specific attributes like color, product name, size etc using the pattern matching approach with a help of set of predefined grammar rules.

Then extracted product related attributes are sent to a back end server. Products details (Image, description etc.) displays on a tab - when NAO gets a SUCCESS response from the back end server and then it points the display to the customer.

NAO robot detects voice request and extracts product attributes using grammar rule extractor.
Send product attributes through a web socket connection to the tablet application and tablet application forwards the request to the Product API.
Captures the product search request and performs indexed search on given attributes.
Sends product result response back to tablet application ( List of products with images and descriptions). Check the response state.
Displays the responses on the display.
Sends back SUCCESS response to NAO ( if tab application timeout / FAIL state for product search request - application sends FAIL state response back to NAO and terminate socket connection)

In addition to the product display, application captures customer selected (clicked) product name and sends it back to the NAO as a product select event. In order to keep the interaction with customer and provide a good expereince, NAO responses and do some activities based on the selected products (Give some promotion codes etc.) .

I have used NAO’s sonar sensor to identify whether the customer still stand nearby if the customer does not engage with the NAO. if the customer no longer engage with NAO, it waits some time and end the customer session while coming back to the default position and setting the display to main page.

NAO programming : Python + NAO Python API

Backend Server : Node Js

Tablet Application : Node Js + Angular Js

NOTE: Aldebaran Robotics has introduced a new humanoid robot called Pepper targeting retail industry with a inbuilt display and Romeo with more advanced features.

HBase - Avoid RegionServer Hotspotting

noreply@blogger.com (Anonymous) — Mon, 19 Dec 2016 09:29:00 +0000

Hbase

Hbase architecture follows the master server architecture. Region servers serve data for reads and writes. When accessing data, clients communicate with hbase region servers directly and Hbase Master handles region assignment, creation and deletion of tables. Hbase uses Hadoop distributed file system and stores all data on top of the HDFS files. Also Hbase uses Zookeeper to maintain the distributed tasks and track the health of the cluster.

The Hadoop Data Nodes stores the data of the Region servers and region servers are collocated with the HDFS data nodes while preserving the data locality.

Hbase tables are divided horizontally by row key range into Regions and a region contains all the rows in the table between the region’s start and end key

Hbase maintains a special catalog table called as META table which tracks the location of the regions in the cluster of row keys and zookeeper stores the location of the META table.

There is a special HBase Catalog table called the META table, which holds the location of the regions in the cluster. ZooKeeper stores the location of the META table.

To view more details on Hbase architecture refer this.

Hbase Hotspotting

Records in Hbase are stored as sorted list of row keys according to the lexicographically order and allows fast access to an individual record by its key or fast fetching of a range of data between a given start and end row keys.

Simply we can refer row keys with natural sequence at data insertion time, but this can cause regionserver hotspotting.

By its default behavior Hbase stores rows with similar keys to the same region. When records with sequential keys are being written to HBase, all this data writes hit one Region. So large amount of client traffic is directed at one node, or only a few nodes, of a cluster.

But this would not be a problem if a Region was served by multiple Region Servers since the writes gits multiple region server even they serves as a single region.

But the common situation is that each Region lives on just one Region Server and each Region has a predefined maximal size. If a Region reaches that maximal size it is split in two smaller Regions becoming a hotspot victim because one of these new Regions takes all new records (Limits the write throughput to the capacity of a single server instead of making use of multiple/all nodes in the HBase cluster).

Solutions for Hbase Hotspotting

Add a salt to the Row Key

Include a random data to the start of a row key (randomly assigned prefix) to cause it to sort differently than it otherwise would. Salting prefixes can be used correspond to the number of regions we want spread the data.

Use of Hashed Row Key

This approach is suitable when application reads query a record at a time and records will spread between multiple regions / region servers according to the hash function. Using a deterministic hash allows the client to reconstruct the complete row key and use a Get operation to retrieve that row as normal.

Reverse the row key

Reverse a fixed-width or numeric row key so that the part that changes the most often (the least significant digit) is first. This effectively randomizes row keys, but sacrifices row ordering properties.

Bucketing approach

row_key = (++index % BUCKETS_NUMBER) + original_key

Where,

index - The numeric (or any sequential) part of the specific record.

BUCKETS_NUMBER - the number of “buckets” we want our new row keys to be spread across.

original_key - The original key of the record we want to write.

New row keys of bucketed records will no longer be in one sequence, but records in each bucket will preserve their original sequence. Since data is placed in multiple buckets during writes, we have to read from all of those buckets when doing scans based on “original” start and stop keys and merge data so that it preserves the “sorted” attribute. Scan per bucket can be parallelized and so the performance won’t be degraded.

Implement A Digital Signature Batch Screening For Elgamal

noreply@blogger.com (Anonymous) — Sat, 28 Feb 2015 16:34:00 +0000

ElGamal

The ElGamal Encryption Scheme is an asymmetric key encryption algorithm for public key cryptography algorithm for public key cryptography and it is based on Diffie Helman key exchange.

Key generation

Randomly choose a secret key x with 1 < x < p − 1.

Compute y = g^x mod p.

The public key is (p, g, y).

The secret key is x.

These steps are performed once by the signer.

Signature generation

To sign a message m the signer performs the following steps.

Choose a random k such that 1 < k < p − 1 and gcd(k, p − 1) = 1.

Compute .

Compute .

If start over again.

Then the pair (r,s) is the digital signature of m. The signer repeats these steps for every signature.

Verification

A signature (r,s) of a message m is verified as follows.

and .

The verifier accepts a signature if all conditions are satisfied and rejects it otherwise.

Batch verification approach

In modified version of ElGamal Batch verification approach, multiplication of is computed for a batch of r and s. Then get the summation of collision-resistant hash value for every message and checks for the equality of both values of summation of hash and the multiplication of

A signature (r,s) of a message m is verified as follows.

and .

The verification scheme accepts a signatures if all conditions are satisfied and rejects if there exists at least one forged signature.

Results

Code

2D Game Development Using Java – Introduction

noreply@blogger.com (Anonymous) — Wed, 15 May 2013 09:04:00 +0000

Introduction

Battle Tank was developed as a small 2D game which is controlled by an AI (Artificial Intelligent) at client side and this game is a multiplayer game which allows to connect five maximum player and communication is handled by a central server which is developed in C# language.

Game Server

Server architecture

A timer gets initiated when the first player resister for a game server.Client has to send a request to the sever saying JOIN# in order to connect to the server. Then the server replies following replies.

S:P<num>: < player location x>,< player location y>:<Direction># -Join accept message where directions are 0-North, 1-East, 2-South, 3-West.
—PLAYERS_FULL# – The maximum number of players are already connected to the server.
ALREADY_ADDED# – The player is already connected to the game server.
GAME_ALREADY_STARTED# – The player tries to join an already started game

At the game initiation all other map details are sent in the following format.

I:P1; < player location x>,< player location y>;: …: P5< player location x>,< player location y>;: < x>,;< x>,;< x>,….. < x>,: < x>,;< x>,;< x>,…..< x>,: < x>,;< x>,;< x>, …..< x>,# where players details:Brick details:Stone coordinates:Water coordinates.

—When the client want to move or rotate its tank or shoot, client must issue the relevant command from —UP#, —DOWN#, —RIGHT#, —LEFT# or —SHOOT#. If the request of the client cannot be honoured server will be immediately communicated following messages.

—OBSTACLE#
—CELL_OCCUPIED#
—DEAD#
—TOO_QUICK#
—INVALID_CELL#
—GAME_HAS_FINISHED#
—GAME_NOT_STARTED_YET#
—NOT_A_VALID_CONTESTANT#

Once per second the server broadcasts a global update to all the clients documenting its internal variables about the clients in following format.

G:P1;< player location x>,< player location y>;;< whether shot>;;< coins>;< points>: …. P5;< player location x>,< player location y>;;< whether shot>;;< coins>;< points>: < x>,,;< x>,,;< x>,,;< x>,,…..< x>,,#

The server sends C:<x>,<y>:<Life Time in milliseconds>:<Value># message to signal the appearing event of a pile of coins and sends L:<x>,<y>:<LT># message to signal the event of a life pack. —When the game ends, the player with most points will be declared the winner and the message GAME_FINISHED# broadcasts to all the clients.

Download server here

2D Game Development Using Java - Design Graphical User Interface For The Client Application

noreply@blogger.com (Anonymous) — Tue, 14 May 2013 03:36:00 +0000

Approach

Client side application was implemented using java and java classes were used for each object (Tanks,

Bricks,Stones and Water).In this application Actor java class is handled the collisions and extends it in every child classes and the graphic abstract class repaints the map after that the application is received a broadcast message from the server.

Code

Sample child class – Player,

GameBoard was implemented by extending a Jpanel for display map details.

Tyron Josh- Development Assignment Of Josh Operating System

noreply@blogger.com (Anonymous) — Fri, 23 Mar 2012 06:29:00 +0000

What is TYRON JOSH OS ?

TYRON JOSH is a modified version of JOSH operating system in order to display the hardware information of the machine and it was implemented as an assignment for the module CS 2042-OPERATING SYSTEM.
The main issue in JOSH operating system is that it was implemented in order to boot from a floppy disk (FAT12 file format). But for this I followed following instructions to boot JOSH OS using a USB pen drive.

Linux Environment uses ordinary files format to represent various I/O devices and these files are in /dev directory and when an USB pen is plugged in, ansdb file and sdb1 file is created in /dev directory.
sdb -represents the device itself
sdb1 -primary partition on that device.

Procedure

Step 1-
Format the pen to FAT32 file system using following command.

sudo /sbin/mkdosfs -F 32 -I /dev/sdb

–F 32flag – causes the device to be formatted in FAT32 file system format
-Iflag -required to force direct formatting of the device file
FAT12 file format can handle disks minimum than 32MB. Because of that I failed to directly use the following command

sudo/sbin/mkdosfs -F 12 -I /dev/sdb

Step 2-
Create a floppy disk image,

sudo dd if=/dev/zero bs=512 count=2880 of=./floppy.img

Format the floppy image,

sudo /sbin/mkdosfs –F 12 ./floppy.img

Override thefloppy image to the USB pen,

sudo dd if=./floppy.img of=/dev/sdc

Put the boot binary file into the boot sector of the disk.

sudo dd if=./boot.bin of=/dev/sdc

Then I successfully booted the JOSH operating system using my USB drive.

Approach

There are two basic methods are using in assembly language to get the hardware information.
1. Use BIOS Service interrupts
2. Use special commands
In this implementation both two approaches are used and handling BIOS service interrupts is quite complex with comparing to the use special processor commands.

1. Use BIOS Service interrupts

By using the BIOS interrupts we can get the hardware information which are stored in BIOS data area. Basically when we call an interrupt it will return the AX register with corresponding data.
Ex: Print a word to the screen using BIOS interrupt 0x21, the following x86 assembly language instructions would be executed:

mov si, strproserial

mov al, 0x01

int 0x21

There are two kinds of interrupts.
a. Processor interrupts
Interrupts 00h to 07h are called by the processor directly, but can also be called from software using the INT (int) instruction.

b. Hardware interrupts
The hardware interrupts differ from all the software interrupts. They have a direct channel to the processor thorough an Interrupt Request Line. The 8259 Programmable Interrupt Controller or PIC on the motherboard manages all the hardware interrupts.

2. Use special commands

We can use a special command to view processor details. These special commands are provided by the processor manufacturers. The CPUID (cpuid)command requires without any operand, but it takes an argument from the EAX register. Therefore we should store a value in EAX register before calling the CPUID command.
Ex: CPUID functions that return the basic processor information, the program should set the EAX register parameter value to “0”and then execute the CPUID instruction as follows:

MOV EAX, 00h

CPUID

Methods that are implemented-
Display the hardware details separately.

_cmd_displayHardwareInfo:

call _display_endl

mov si, strCPUID

mov al, 0x01

int 0x21

call _cmd_cpuVendorID

call _cmd_ProcessorType

call _cmd_ProcessorSerialNo

;call _cmd_ProcessorFeature

;call _cmd_MouseStatus

ret

display the vendor ID of the processor

_cmd_cpuVendorID:

mov eax,0

cpuid; call cpuid command

mov [strcpuid],ebx; load last string

mov [strcpuid+4],edx; load middle string

mov [strcpuid+8],ecx; load first string

call _display_endl

mov si, strcpuid;print CPU vender ID

mov al, 0x01

int 0x21

ret

This method is implemented using the special commands.

When we call cpuid method with value of 0 to the register EAX ,it returns vendor ID and return it as 12 bytes value and this values stores in EBX, EDX, ECX registers because these registers each is 32 bit. So first I declare a memory location by the reference strcpuid name with the size of 12 bytes.

strcpuidresb12                  ;12 bytes for store vendor ID string

Display the processor type, speed of the processor.

_cmd_ProcessorType:

mov eax,0x80000002

cupid     ; call cpuid command

mov [strcputype]   ,eax

mov [strcputype+4] ,ebx

mov [strcputype+8] ,ecx

mov [strcputype+12],edx

mov eax,0x80000003

cpuid; call cpuid command

mov [strcputype+16],eax

mov [strcputype+20],ebx

mov [strcputype+24],ecx

mov [strcputype+28],edx

mov eax,0x80000004

cupid     ; call cpuid command

mov [strcputype+32],eax

mov [strcputype+36],ebx

mov [strcputype+40],ecx

mov [strcputype+44],edx

call _display_endl

;mov si, strProcessor

;mov al, 0x01

;int 0x21

call _display_space

mov si, strcputype           ;print processor type

mov al, 0x01

int 0x21

ret

Same as the above method when we call cpuid method with value of 0x80000002,0x80000003, 0x80000004 seperately to the register EAX ,it returns processor type and return it as 12bytesvalueand this values stores in EBX, EBX, ECX, EDX at each time that calls cpuid command. So first I declare a memory location by the reference strcputype name with the size of 48bytes.

strcputype resb48           ; 48 bytes for store cpu type string

Prints TRUE if a mouse is connected to the machine, if not it prints FALSE. This method is implemented using interrupt and BIOS data area.

call _display_endl

xor ax,ax                ; clean out the AX register

;mov si, strmouse

;mov al, 0x01

;int 0x21

call _display_space

push ax

push dx

int 33h                  ; call interrupt 33h function 0

cmp ax,0ffffh            ; compare AX and FFFFh (installed)

jne _mouseAvailable      ; if so Jump to print true

jmp _mouseNotAvailable   ; if notDisplay the word "false"

ret

_mouseAvailable:            ;print 'true'

mov si, strmousetrue

mov al, 0x01

int 0x21

ret&lt;

_mouseNotAvailable:    ;print ‘false’

mov si, strmousefalse

mov al, 0x01

int 0x21

ret

_cmd_callHelp:

call _display_endl

mov si, strCmd0

mov di, cmdHelp

mov cx, 5

repecmpsb

;jne_cmd_ver

jne_cmd_exit

call cmd_displayHelpMenu

call _display_endl

jmp _cmd_done

Prints the help menu,

cmd_displayHelpMenu:

call _display_endl

mov si, strHelpMsg0;print help message

mov al, 0x01

int 0x21

call _display_endl

mov si, strHelpMsg1

mov al, 0x01

int 0x21

call _display_endl

mov si, strHelpMsg2

mov al, 0x01

int 0x21

call _display_endl

mov si, strHelpMsg3

mov al, 0x01

int 0x21

ret

Let me know

Redis Cluster Client for Erlang

Redis

Redis Clustering

Erlang Redis Cluster Client - eredis_cluster_client

Hands on k-Nearest Neighbour Algorithm - (k-NN)

What is k-NN Algorithm?

Efficiency & Accuracy Improvements

Hands on Pig Unit Testing

Why Unit Testing ?

What is Pig ?

Familiar with Pig Unit Test ?

Load Dynamic & Complex Json Messages in Pig Script without a schema

Load Complex & Dynamic JSON messages - Problem

How to use Elephant-bird - Solution

Next Level Shopping Experience - Adapt NAO Humanoid Robot Features In Customer Care

Humanoid Robot ?

Integrate a Display to NAO

HBase - Avoid RegionServer Hotspotting

Hbase

Hbase Hotspotting

Solutions for Hbase Hotspotting

Use of Hashed Row Key

Reverse a fixed-width or numeric row key so that the part that changes the most often (the least significant digit) is first. This effectively randomizes row keys, but sacrifices row ordering properties.

Implement A Digital Signature Batch Screening For Elgamal

ElGamal

Key generation

Randomly choose a secret key x with 1 < x < p − 1. Compute y = g x mod p. The public key is (p, g, y). The secret key is x. These steps are performed once by the signer.

Signature generation

To sign a message m the signer performs the following steps. Choose a random k such that 1 < k < p − 1 and gcd(k, p − 1) = 1. Compute . Compute . If start over again. Then the pair (r,s) is the digital signature of m. The signer repeats these steps for every signature.

Verification

A signature (r,s) of a message m is verified as follows. and . The verifier accepts a signature if all conditions are satisfied and rejects it otherwise.

Batch verification approach

Results

Code

2D Game Development Using Java – Introduction

Introduction

Game Server

2D Game Development Using Java - Design Graphical User Interface For The Client Application

Approach

Code

Tyron Josh- Development Assignment Of Josh Operating System

What is TYRON JOSH OS ?

Procedure

Approach

1. Use BIOS Service interrupts

2. Use special commands

Randomly choose a secret key x with 1 < x < p − 1.

Compute y = g^x mod p.

The public key is (p, g, y).

The secret key is x.

These steps are performed once by the signer.

To sign a message m the signer performs the following steps.

Choose a random k such that 1 < k < p − 1 and gcd(k, p − 1) = 1.

Compute .

Compute .

If start over again.

Then the pair (r,s) is the digital signature of m. The signer repeats these steps for every signature.

A signature (r,s) of a message m is verified as follows.

and .

The verifier accepts a signature if all conditions are satisfied and rejects it otherwise.