Recently the webhost Ipower migrated to a new hosting platform called Vdeck 3.0. In so doing, some of the changes have caused certain php powered applications to stop working. I believe this also affects a few other hosts such as Powweb and Ipowerweb, and any Ipower reseller hosts that just upgraded to vdeck 3.0.There are two ways to solve the problem. The best way would be to edit your php.ini file. However, out of fear of breaking all my working PHP applications, I decided to simply made a change in the applications not currently working to fix the issue.

The following is the solution I used.

I created a folder called “phpsessions” outside of my public_html folder. That is to say, if the following is the path to my public_html folder:

/home/users/blah/blah/public_html

then I created:

/home/users/blah/blah/phpsessions/

Next, open up your PHP application and look for the file where you start your sessions using “session_start();”

Look for:

Quote:

Replace with:

Quote:

Hopefully this solution will help others experiencing problems with their PHP applications!

The SQLDebugger Windows user account is created when the SQL Debugger Registry2 DCOM server process (Sqldbreg2.exe) is registered. If you’ve installed SQL Server, then this process will be registered and therefore the SQLDebugger Windows user account will be created on your system. This account is used for connecting to a database server for debugging purposes. In such a case, you may actually want to keep the user account… But what if you haven’t even installed SQL Server… What the heck is SQLDebugger doing on your computer then?

Microsoft Visual Studio .NET applications use SQL Server Debugging to debug SQL Server stored procedures. So guess what that means? If you’ve installed Microsoft Visual Studio .NET, then you’ll have the SQLDebugger Windows user account created on your machine, even if you have no intentions of ever using it. While there is no danger in keeping the SQLDebugger account around, since it was created without your permission or without you even knowing about it and since it serves no purpose unless you are doing database debugging, JUST DELETE IT!

That being said, how the heck do you actually do it?

First, open up “viewforum_body.html”. If you are using the prosilver theme you can find this file here:

styles/prosilver/template/viewforum_body.html

Now search that file for the following text:

<!-- END postrow -->

Right before the line above, paste the following code into the file:

<!– IF postrow.S_FIRST_ROW –>
<div class=”post bg2″>
<div class=”inner”><span class=”corners-top”><span></span></span>

<div class=”postbody”>
<h3>Sponsor</h3>

<div class=”content” style=”text-align: center;”>
THE CODE FOR YOUR AD GOES HERE
</div>
</div>

<dl class=”postprofile” id=”profile0000″>
<dt>
<strong><u>Featured Sites</u></strong>
</dt>

<dd><a href=”http://www.looble.com”>Looble Network</a></dd>
<dd><a href=”http://www.free-games-center.com/”>Free Games Center</a></dd>
<dd><a href=”http://www.software-engineer-training.com/”>Software Engineer Training</a></dd>
<dd><a href=”http://flogger.looble.com/”>Flogger</a></dd>
<dd><a href=”http://www.writerdatabase.com/”>Writer Database</a></dd>
<dd><a href=”http://www.tamramaew.com/”>Tamra Maew</a></dd>
<dd><a href=”http://www.squishyrecords.com/”>Squishy Records</a></dd>
</dl>

<div class=”back2top”><a href=”#wrap” class=”top” title=”{L_BACK_TO_TOP}”>{L_BACK_TO_TOP}</a></div>
<span class=”corners-bottom”><span></span></span></div>
</div>
<hr class=”divider” />
<!– ENDIF –>

Make sure you place your ad code where I have bolded text above. Upload your new file and you are set! Out of love, we highly recommend you at least keep the Software Engineer Training link as one of your featured sites.

• Most current CVS features.Subversion is meant to be a better CVS, so it has most of CVS’s features. Generally, Subversion’s interface to a particular feature is similar to CVS’s, except where there’s a compelling reason to do otherwise.
• Directories, renames, and file meta-data are versioned.Lack of these features is one of the most common complaints against CVS. Subversion versions not only file contents and file existence, but also directories, copies, and renames. It also allows arbitrary metadata (”properties”) to be versioned along with any file or directory, and provides a mechanism for versioning the `execute’ permission flag on files.
• Commits are truly atomic.No part of a commit takes effect until the entire commit has succeeded. Revision numbers are per-commit, not per-file; log messages are attached to the revision, not stored redundantly as in CVS.
• Apache network server option, with WebDAV/DeltaV protocol.Subversion can use the HTTP-based WebDAV/DeltaV protocol for network communications, and the Apache web server to provide repository-side network service. This gives Subversion an advantage over CVS in interoperability, and provides various key features for free: authentication, wire compression, and basic repository browsing.
• Standalone server option.Subversion also offers a standalone server option using a custom protocol (not everyone wants to run Apache 2.x). The standalone server can run as an inetd service, or in daemon mode, and offers basic authentication and authorization. It can also be tunnelled over ssh.
• Branching and tagging are cheap (constant time) operationsThere is no reason for these operations to be expensive, so they aren’t.Branches and tags are both implemented in terms of an underlying “copy” operation. A copy takes up a small, constant amount of space. Any copy is a tag; and if you start committing on a copy, then it’s a branch as well. (This does away with CVS’s “branch-point tagging”, by removing the distinction that made branch-point tags necessary in the first place.)
• Natively client/server, layered library design Subversion is designed to be client/server from the beginning; thus avoiding some of the maintenance problems which have plagued CVS. The code is structured as a set of modules with well-defined interfaces, designed to be called by other applications.
• Client/server protocol sends diffs in both directionsThe network protocol uses bandwidth efficiently by transmitting diffs in both directions whenever possible (CVS sends diffs from server to client, but not client to server).
• Costs are proportional to change size, not data sizeIn general, the time required for a Subversion operation is proportional to the size of the changes resulting from that operation, not to the absolute size of the project in which the changes are taking place. This is a property of the Subversion repository model.
• Choice of database or plain-file repository implementationsRepositories can be created with either an embedded database back-end (BerkeleyDB) or with normal flat-file back-end, which uses a custom format.
• Versioning of symbolic linksUnix users can place symbolic links under version control. The links are recreated in Unix working copies, but not in win32 working copies.
• Efficient handling of binary filesSubversion is equally efficient on binary as on text files, because it uses a binary diffing algorithm to transmit and store successive revisions.
• Parseable outputAll output of the Subversion command-line client is carefully designed to be both human readable and automatically parseable; scriptability is a high priority.
• Localized messagesSubversion uses gettext() to display translated error, informational, and help messages, based on current locale settings.
• Repository mirroringSubversion supplies a utility, svnsync for synchronizing (via either push or pull) a read-only slave repository with a master repository.

For those using Windows, you should also install TortoiseSVN. TortoiseSVN will allow you to easily interact with Subversion directly through Windows Explorer. While viewing files saved on your system, if you right-click the screen you’ll see some new commands that will allow you to connect to your SVN repository and add or checkout files.

In order to use TortoiseSVN you need to first install Subversion and set up a Subversion repository where the program can keep the copies of the documents that you’ve checked in. Subversion will then only save differences between versions of files that you’re storing in its repository. This is much more efficient than making copies of all files and ending up with multiple copies of the same files.

To create a repository, at a command prompt issue the following command:

svnadmin create –fs-type=fsfs /data/SvnRepository

The directory specified above should be an empty directory!

The next step once everything is installed is to just play with it and figure out how to work it before using it on an actual project. Remember, always play before work!

Reasons for TCP

The Internet Protocol (IP) works by exchanging groups of information called packets. Packets are short sequences of bytes consisting of a header and a body. The header describes the packet’s destination, which routers on the Internet use to pass the packet along, in generally the right direction, until it arrives at its final destination. The body contains the application data.

In cases of congestion, the IP can discard packets, and, for efficiency reasons, two consecutive packets on the internet can take different routes to the destination. Then, the packets can arrive at the destination in the wrong order.

The TCP software libraries use the IP and provides a simpler interface to applications by hiding most of the underlying packet structures, rearranging out-of-order packets, minimizing network congestion, and re-transmitting discarded packets. Thus, TCP very significantly simplifies the task of writing network applications.

Source: http://en.wikipedia.org/wiki/Transmission_Control_Protocol

Applicability of TCP

TCP is used extensively by many of the Internet’s most popular application protocols and resulting applications, including the World Wide Web, E-mail, File Transfer Protocol, Secure Shell, and some streaming media applications.However, because TCP is optimized for accurate delivery rather than timely delivery, TCP sometimes incurs long delays while waiting for out-of-order messages or retransmissions of lost messages, and it is not particularly suitable for real-time applications such as Voice over IP. For such applications, protocols like the Real-time Transport Protocol (RTP) running over the User Datagram Protocol (UDP) are usually recommended instead.

Source: http://en.wikipedia.org/wiki/Transmission_Control_Protocol

Using TCP

Using TCP, applications on networked hosts can create connections to one another, over which they can exchange streams of data using stream sockets. TCP also distinguishes data for multiple connections by concurrent applications (e.g., Web server and e-mail server) running on the same host.

In the Internet protocol suite, TCP is the intermediate layer between the Internet Protocol (IP) below it, and an application above it. Applications often need reliable pipe-like connections to each other, whereas the Internet Protocol does not provide such streams, but rather only best effort delivery (i.e., unreliable packets). TCP does the task of the transport layer in the simplified OSI model of computer networks. The other main transport-level Internet protocols are UDP and SCTP.

Applications send streams of octets (8-bit bytes) to TCP for delivery through the network, and TCP divides the byte stream into appropriately sized segments (usually delineated by the maximum transmission unit (MTU) size of the data link layer of the network to which the computer is attached). TCP then passes the resulting packets to the Internet Protocol, for delivery through a network to the TCP module of the entity at the other end. TCP checks to make sure that no packets are lost by giving each packet a sequence number, which is also used to make sure that the data is delivered to the entity at the other end in the correct order. The TCP module at the far end sends back an acknowledgment for packets which have been successfully received; a timer at the sending TCP will cause a timeout if an acknowledgment is not received within a reasonable round-trip time (or RTT), and the (presumably) lost data will then be re-transmitted. The TCP checks that no bytes are corrupted by using a checksum; one is computed at the sender for each block of data before it is sent, and checked at the receiver.

Source: http://en.wikipedia.org/wiki/Transmission_Control_Protocol

Services Provided by TCP

TCP provides more services than UDP because it is connection oriented whereas UDP is not. TCP allows for point-to-point communication, adressing, multiplexing, demultiplexing, reliability, full-duplex communication, flow control and congestion control.

The reason the whole internet can actually even work is in part thanks to the design of TCP which can dynamically adapt to different properties such as bandwidth, delay and packet loss as well as recover from errors.

TCP splits user data into pieces no larger than 64K bytes and then sends each of these pieces as separate IP datagrams. When these IP datagrams are received at the destination, TCP reconstructs the original byte stream. In order to establish the connection between the sender and destination, sockets are used. Sockets are really just the combination of an IP address and a port number.

A connection is established between two computers using what is called a “three-way handshake”.

The originator (you, hopefully) sends an initial packet called a “SYN” to establish communication and “synchronize” sequence numbers in counting bytes of data which will be exchanged. The destination then sends a “SYN/ACK” which again “synchronizes” his byte count with the originator and acknowledges the initial packet. The originator then returns an “ACK” which acknowledges the packet the destination just sent him. The connection is now “OPEN” and ongoing communication between the originator and the destination are permitted until one of them issues a “FIN” packet, or a “RST” packet, or the connection times out. All the protocols of the Internet which need “connections” are built on the TCP protocol. The “three way handshake” establishes the communication. Much like you picking up your phone, getting a dial tone, dialing the number, hearing ringing, and then the other party saying “hello” or “mushi mushi.”

Source: http://www.pccitizen.com/threewayhandshake.htm

TCP also closes a connection gracefully. Upon closing, the last data segment is followed by a FIN which also has a sequence number associated with it. This way, if the FIN arrives before all segments are received, it will wait for the expected data before closing.

The biggest source of errors in message transmission come from segments damaged in transmission or segments which entirely fail to arrive. The sender obviously does not know if the message sent has been received at the destination or not so it is necessary in TCP for the receiver to acknowledge receipt. In UDP, since reliability is not a concern and since it is a connectionless protocol, this acknowledgment does not occur.

Of course, we need to switch our point of view as soon as the destination sends an acknowledgment because at this point the receiver is acting as a sender. It is therefore entirely possible that the acknowledgment message gets lost or damaged in transmission as well. Therefore, it is necessary to have timers on both the sender and receiver which trigger a re-send after a certain amount of time to make sure the application does not end up in a dead-lock state where both sides are waiting to receive something from the other.

What is the value of the timer? It is possible to have a fixed timer or to use an adaptive scheme. Depending on the network, different value will be more appropriate for different situations and even for a given network, the perfect value can change depending on the amount of traffic on the network. If the timer value is set to be too short, re-transmission will clog the network causing further delay and therefore leading to even more ACK’s being sent! This can therefore become a rather messy situation. Of course, if the timer is set too high, performance will suffer because the delay before re-transmission leads to the application sitting and waiting. Therefore, the ideal timer will have some functionality to be aware of network conditions and then use this information in order to dynamically increase or decrease the timer.

Another problem thatmust be dealt with arises from the fact that TCP re-transmits messages as stated above in order to guarantee transmission. Since messages and ACK’s may be re-transmitted, we suddenly end up in a situation where it is possible for the destination to receive duplicates. For example, imagine that the receiver sends an ACK in order to confirm receipt of a message but high network traffic causes this ACK to travel slowly. Meanwhile the sender is waiting for the ACK when suddenly it’s timer expires and it therefore decides to re-transmit the message. Right after sending the message the ACK might finally arrive, however the duplicate has already been sent! The sender will now not send the message a third time because the ACK was received but the receiver will need to deal with the duplicate message that will soon be arriving! In order to deal with duplicates, the receiver can use the sequence number to determine if the message has already been received. However, for this to work correctly we are assuming that the sequence number space is large enough that it does not restart within the life-span of a packet. In a nutshell, the sequence space is a fixed number. When a connection is established the first message always starts at the first sequence number and eventually, if the connections has been open long enough and many messages have been sent, eventually the last available sequence number is reached. At this point, the next message sent will start back at the first sequence number. Therefore, it is possible for two messages with the same sequence number to exist and not be duplicates!

Congestion is caused when too much traffic is flowing through a network that individual messages are delayed because messages are arriving more quickly than can be processed. When this occurs, routers will begin dropping packets, starting with those it feels are of a lower priority. Therefore, as congestion occurs, time-outs start to happen causing messages to be re-transmitted. This of course is done in order to make sure the message does in fact arrive, but for a system experiencing congestion, this reliability feature imply contributes to the congestion. TCP congestion control handles this by estimating the round trip delay by observing patterns of delay and then setting the timer so a value greater than the time estimated. The timer is set higher in order to account for round trip time variance.

RTO – Re-transmission timeout

As discussed above, a timer is set on both the sender and receiver upon transmitting a message. If an acknowledgment is not received before this timer expires then a time-out occurs which triggers the re-transmission of the message. Using a fixed timer is not a good idea because the main cause for such occurring is congestion. If congestion occurs on your network and you message times-out, if you re-transmit the same message and keep the timer at the same value, chances are the message will time-out yet again if network conditions have not improved. Therefore, if we assume congestion is the culprit, it is important to give the message some extra time upon re-transmission in order to see if this extra time is enough for it to reach the destination and be acknowledged. The act of increasing the timer each time a message is re-transmitted is referred to as re-transmission timeout backoff. The most common type of RTO backoff is binary exponential backoff which takes the current timer value and multiplies it by two each time a message is re-transmitted.

Another issue that is important to consider is with respect to shrinking the timer back down. Re-transmitted messages should never be used as a guage when measuring RTT (round trip time) because the acknowledgment received could actually be for the first message transmitted and not for the re-transmitted one! Therefore, the RTO backoff should continue to be used until an ACK arrives for a message that has not been re-transmitted. At this point, it is up to the designer to decide how to implement the system. The timer can be left constant for a given amount of time and then upon receiving a certain number of messages without needing to re-transmit, the timer value can be divided by two in order to shrink it back down, meaning that perhaps network conditions have improved.

Window Management

Slow-start is part of the congestion control used in TCP in order to avoid sending more data than the network is able to handle.

Slow-Start Algorithm

A slow-start algorithm consists of two distinct phases: the exponential growth phase, and the linear growth phase.

During the exponential growth phase, Slow-start works by increasing the TCP congestion window each time the acknowledgment is received. It increases the window size by number of segments acknowledged. This happens until either an acknowledgment is not received for some segment or a predetermined threshold value is reached. If a loss event occurs, TCP assumes this it is due to network congestion and takes steps to reduce the offered load on the network. Once a loss event has occurred or the threshold has been reached, TCP enters the linear growth (congestion avoidance) phase. At this point, the window is increased by 1 segment for each RTT. This happens until a loss event occurs.

Although the strategy is referred to as “slow-start”, its congestion window growth is quite aggressive.

The algorithm begins in the exponential growth phase initially with a congestion window size (cwnd) of 1 or 2 segments and increases it by 1 Segment Size (SS) for each ACK received. This behavior effectively doubles the window size each round trip of the network. This behavior continues until the cwnd reaches the size of the receivers advertised window or until a loss occurs.

When a loss occurs half of the current cwnd is saved as a Slow Start Threshold (SSThresh) and slow start begins again from its initial cwnd. Once the cwnd reaches the SSThresh TCP goes into congestion avoidance mode where each ACK increases the cwnd by SS*SS/cwnd. This results in a linear increase of the cwnd.

Source: http://en.wikipedia.org/wiki/Slow-start

TCP Data Transfer

When a TCP connection is established, a stream of bytes is what will actually be sent between communicating entities, not messages. Messages themselves can be sent by any combination of pieces which give a total of 2048 bytes. Therefore, is you wish to send 4 messages each of which are 512 bytes, TCP might not actually send your message right away if it is set to wait for a total of 2048 bytes before transmitting. If this is the case, it will not send your 512 byte messages until 4 of these such messages are ready to be sent. TCP could also instead be set to send 2 pieces each of size 1024 bytes, and therefore only 2 messages need be ready in order to be transmitted. The important thing to understand is that a message being ready to be sent does not mean that this message itself is sent, but rather pieces of bytes which are then re-combined in order to re-create the message. Also, its important to note that TCP may decide to wait with your message and collect more data before transmitting. Certain flags can be used in order to request no delay.

TCP Header

Source: http://www.visi.com/~mjb/Drawings/

TCP Header Fields

Source and destination port – 16 bit address corresponding to the port which is associated with the value defined in the socket used to establish the connection.

Sequence and acknowledgment numbers – These are both 32 bit numbers which are used to help ensure reliable delivery of messages. Every TCP packet send has a sequence number associated with it and the acknowledgment is used to communicate to the other entity which sequence number is expected next.

URG – this will be set to 1 if the urgent pointer is used. The pointer will indicate an offset from the current sequence number which informs the receiver at which point the urgent data ends.

ACK – set to 1 to indicate the acknowledgment is valid.

PSH – set to 1 to indicate pushed data. Pushed data is data that the sender force-delivered without waiting for the buffer to fill.

RST – set to 1 to indicate a reset. This can be used to reject a connection or to refuse an invalid segment. It can also be used if the host has become confused for whatever reason and therefore would like to re-establish the connection.

SYN – used in order to establish a connection. If SYN = 1 an ACK = 0 then a connection request is in progress. If SYN = 1 and ACK = 1 then a connection acceptance is in progress.

FIN – this is set to 1 in order to indicate the end of user data and to therefore close the connection. As discussed earlier, data may still be received after the FIN because the FIN also has a sequence number associated with it and it is possible that messages with an earlier sequence number arrive after the FIN which should actually be processed and which are.

TCP Error Checking

Error checking is accomplished by using the checksum field available in the TCP header. The receiver performs a calculation on the checksum field and the user data and if the result is not 0, this indicates that there is an error somewhere.

TCP Options

The options field available in the TCP header allows for extra features to be used or certain settings to be set. Below are some example:

- During connection, this field is used for connecting entities to negotiate an acceptable maximum segment size.

- Since network speeds have increased dramatically since TCP was first introduced, 16 bits used for sequence numbers is actually no longer enough and the problem of incorrect duplicate detection becomes a major concern. It is therefor possible to also use the options field to allow for an increase in the number of available sequence numbers from 2^16 to 2^32.

- The options field can also be used to include a time-stamp which can then be used in order to determine round trip time, information that can then be used for congestion control.

Additional Time Issues

Given all of the information presented above, there are some other issues to consider with respect to the timer. As mentioned a persistence timer is essential in order to avoid deadlock situations. This timer will expire and cause the last message to be re-transmitted if no acknowledgment is received in a timely fashion. When using congestion control, it is possible for the available window size to go down to 0, which causes the sender to stop sending messages temporarily until it is notified that there is space again in the window. Therefore, even in this situation it is still important to occasionally have a timer expire causing the sender to ask the receiver if it has space in its window. This is necessary because imagine if an acknowledgment sent increasing the window size is lost, the system would be stuck waiting forever!

Of course, the above assumes that the problem is due to congestion. It is possible that there is no connection but that the entity you are communicating with is no longer available or has gone offline. Is is therefore also important not to continue trying to send messages to this user forever, but to instead also maintain a keep-alive timer which will occasionally cause a message to be sent to the receiver asking, “are you still there?”. If no response is received, the connection should be terminated so resources are not wasted sending messages to an entity which is no longer available to receive these messages.

The transport layer is one of the 7 layers of the OSI model. It’s purpose is to provide robust end-to-end service to to the upper layers and is responsible for end-to-end delivery of the message. Therefore, the transport layer must consider addressing, reliability, flow control and multiplexing in order to accomplish it’s main goals.

Reliable delivery is not a compulsory service for the transport layer, however since this layer is expected to be responsible for delivering the messages from end-to-end, it only makes sense to implement reliable delivery at this layer. Reliable delivery is provided by using error control, sequence control, loss control and duplication control.

Sequence control is very important because messages not arriving in order can cause very important information to be lost or even overwritten. For example, when one process relies on another, the order in which messages arrive will influence the final result meaning that sequence errors will lead to errors in the application. This is similar to the complexities encountered when working with databases or other applications that are multi-threaded. Consider performing a mathematical calculation. If one process retrieves the stored value to be used in the calculation just before the second process updates that value, then even if that value is updated, the first process is unfortunately using the incorrect value for its calculation.

Of course, if sequence control is an important issue, obviously so it loss control! If messages are not even received, the complexity in dealing with such is far more complex than worrying about putting messages back in order which can be accomplished by the use of sequence numbers. If messages are being lost after transmission over a network, it is not necessary to somehow make sure the lost messages are re-sent in a timely fashion. All this must be accomplished in a way such that performance of the system and entire network is not compromised.

Duplication control is important to consider as well because as the speed of networks continue to increase, it becomes possible for different messages to be identified as duplicated and discarded. Similarly, if a packet can become corrupted or erroneous, it is possible then for the sequence number of a real message to be incorrect and cause a duplicate. Also it is entirely possible for a duplicate message to be sent by the sender itself, and therefore this duplicate should be detected to avoid errors.

Flow control is yet another important component of transport to consider. Imagine all these messages that are being delivered over a network, some coming from very high-speed users, others from slower users possibly still using a dial-up connection. Without flow control, a slower user could quickly become completely flooded with messages and suddenly be unable to do anything. Flow control therefore establishes window sizes to try and make sure the network or users do not run into this problem.

Multiplexing refers to the process where multiple messages are combined into a single signal. Demultiplexing is the reverse process of taking a single signal and splitting it into multiple messages. The transport layer performs a multiplexing (to data link layer)/demultiplexing(from data link layer) function with respect to the interface between itself and the layers below it.

With regard to the transport layer, a connection is not necessarily required since messages can be sent by UDP which is connectionless. Therefore, a connection is only required when a connection-oriented transport protocol is being used. If using a connection-oriented transport protocol, then it is important to consider the complexities involved with connection establishment and connection release. Establishing a connection is a rather straight-forward concept. A connection request is sent, and then the sender waits for an acknowledgment confirming the connection. However, problems can occur when duplicate or expired connection requests or acknowledgments show up!

UDP – User Datagram Protocol

UDP is a way of sending data over a network, however unlike TCP, ordering and reliability is not part of the protocol. Because this reduces a significant amount of overhead, UDP is actually faster and more efficient than TCP. However, for applications that require reliable or guaranteed delivery, UDP will not be acceptable. There is also no flow control or congestion control. UDP can have optional error detection, but does not have any method for recovery. Unlike TCP, UDP is compatible with packet broadcasting which is the sending of a message to everyone on a network

Associative Law:

Distributive Law:

Tautology Law:

Absorption Law:

Demorgan’s Law:

Double Complementation:

Implication:

Complementation:

Disjunction:

Conjunction:

—

[1] – Images from Thomas Jefferson High School for Sciene and Technology

Examples from [1]:

1) Construct a DFA to accept a string containing a zero followed by a one.

2) Construct a DFA to accept a string containing two consecutive zero’s followed by two consecutive ones.

3) Construct a DFA to accept a string containing even number of zeros and any number of ones.

4) Construct a DFA to accept all stings which do not contain three consecutive zeros.

5) Construct a DFA to accept all strings containing even number of zeros and even number of ones.

6) Construct a DFA to accept all strings which satisfy #(x)mod5=2.

7) Construct a DFA to accept all strings (0+1)* with an equal number of zeros and ones such that each prefix has at most one more zero than ones and at most one more one than zeros.

—

[1] – Model Engineering College –

• Read more about CISC (Complex Instruction Set Computer)
• Read more about RISC ( Reduced Instruction Set Computer)

Load/Store/Load Effective Address [2]

Ex: X = $1234, Y=$1000, SP=$0A00

Stack Instructions [2]
SP is decremented before information is transferred

Increment/Decrement [2]

Addition and Subtraction [2]

—

[1] Fredrick M. Cady, Software and Hardware Engineering: Assembly and C Programming for the Freescale HCS12 Microcontroller
[2] Prof. Gilbert Arbez, University of Ottawa CSI3531 Course Notes, Module 4

A program created from assemblhy can be more efficient and faster than a program created with a compiler. One example of why this occurs is because a compiler will store intermediate values used in a calculation in memory whereas a program written in assembly can store the intermediate values in a register which is much faster. However, while there may be performance benefits to programming so close to the machine level, there is a great deal of added complexity which a high-level programming language can remove.

Table 5.1 Source Code Fields [1]

• A label must start with an alphabetic character
• The label must start in the first column of the source code line unless it ends with a colon.
• Uppercase and lowercase characters are distinct by default but case sensitivity may be turned off.
• A label may end with a colon (:)
• A label may appear on a line by itself
• The label is optional but when used it can provide a symbolic memory reference such as a branch instruction address, or a symbol for a constant.

• The opcode field contains either a mnemonic for the operation, an assembler directive or pseudo-operation, or a macro name. For the opcode field, the assembler will convert all uppercase letters to lowercase so this field is not case sensitive.

• The interpretation of the operand field depends on the opcode.
• The operand must follow the opcode.
• Operands can be the symbols, constants, or expressions that are evaluated by the assembler.
• The operand field also specifies the addressing mode for the instruction.

Using Macros

A macro can be used to give a symbolic name to a group of instructions that are used often. In the source code the macro should be given a name using the label field and then two commands (MACRO & ENDM) are used to indicate the start and finish of the macro. The assembler will then replace every occurrence of the macro with the set of instructions.

Macro vs Sub-Routine

A macro and a sub-routine are similar except for the following differences:

• With a sub-routine the code is present only once. With a macro, the code is inserted in the place of the macro whenever it is used. Therefore, if macros are used instead of sub-routines, the code will end up being longer.
• With a sub-routine a jump must occur in order to find and execute the sub-routine code. With a macro, this is not required because the code has already been inserted directly. Therefore, a sub-routine will be slightly slower than a macro.

Using either a sub-routine or a macro makes changing the code much easier because changes can be done in one place rather than in each specific location where the code would be used. They also make the code easier to understand.

Assembler Instructions

ORG – Set the program counter to the origin of the program

EQU – Associate the value of an expression with a symbol

SET – Can be used instead of equal. With set, the value can be redefined

DC – Define a constant value

DCB – Define a constant block

DS – Define storage

Example 5-9 ORG – Set Program Counter to Origin for Absolute Assembly [1]

Software Development Process

When programming in any language, following a good development process is necessary in order to deliver a successful product. It is important to resist the urge to jump right into the code immediately, especially when programming in assembly which is extremely complex.

The first step should always be to clearly identify the problem and define a solution to solve that problem. Create and understand the solution in diagrams or pseudo-code before beginning to code in assembly. Translating these diagrams into code will be much easier than trying envision the solution entirely in your mind.

Debugging and tracing through your assembly program will also be a very good way at finding and correcting bugs.

Typical Bugs Include:

• Incorrect transfer to sub-routine
• Forgetting to initialize the stack pointer
• Not enough memory in the stack
• Sub-routines corrupting registers
• Forgetting to initialize index registers
• Modifying the condition code registers before branching
• Using the wrong branching instruction
• Using the wrong addressing mode

D-Bug12
The D-Bug12 is the debugging tool stored in the EEPROM of our microcontroller that will be used for debugging as well as for downloading programs onto the card and controlling the assembler.

D-Bug12 Commands

ASM – Assemble/Dissasemble

BF – Block Fill Memory

BR – Set Breakpoint

CALL – Call and execute subroutine

G – Go, run program

GT – Go till an address

HELP – Prints summary of available commands

LOAD – Set in state ready to accept program download from MiniIDE

MD – Display Contents of Memory

MM – Modify Memory

MOVE – Copy block of memory

NOBR – Remove breakpoints

RD – Display register contents

T – Trace through program

UPLOAD – Upload memory to PC

USEHDB – Use EVB/Target hardware breakpoints

VERIF – Compare memory to download file

—

[1] Fredrick M. Cady, Software and Hardware Engineering: Assembly and C Programming for the Freescale HCS12 Microcontroller
[2] Prof. Gilbert Arbez, University of Ottawa CSI3531 Course Notes, Module 3