The Pantsir-S1 was designed to provide point air defence of military, industrial and administrative installations against aircraft, helicopters, precision munitions, cruise missiles and UAVs; and to provide additional protection to air defence units against enemy air attacks employing precision munitions, especially at low to extremely low altitudes.[4][5]
The first finished version was completed in 1995 with the 1L36 radar, later another was designed.[6] It is a short to medium range ground-based air defence system, wheeled, tracked or stationary with two to three operators. Its air defense consists of automatic anti-aircraft guns and surface-to-air missiles with radar or optical target-tracking and radio-command guidance.
Sam 6.1 Mechanism Design Software 52
Development as the Pantsir-S started in 1990 as a planned successor to the Tunguska M1. A prototype was completed in 1994 and displayed at the MAKS-1995. The program soon ran into difficulties which resulted in a halt in funding, but KBP continued development of the program using its own funds. Both the turret and radar systems were redesigned, and all older Tunguska equipment was removed.[19]
The Pantsir-S1 carries up to twelve 57E6 (export designation) 57E6-E (export enhanced designation) two-stage solid fuel radio/optical command-guided surface-to-air missiles in sealed ready-to-launch container tubes. Missiles are arranged into two six-tube groups on the turret. The missile has a bicalibre body, consisting of two stages in a tandem configuration. The first stage is a booster, providing rapid acceleration within the first 2 seconds of flight, after which it is separated from the sustainer-stage.
Additional missiles, one specifically designed to engage unmanned aerial vehicles, and another one hypersonic, developing speeds of more than Mach 5, have been developed for the Pantsir system.[17][18][37][38]
Reading Assignments and Exercises This section is organized as follows: 4.1. The Central Processor - Control and Dataflow 4.2. Datapath Design and Implementation 4.3. Single-Cycle and Multicycle Datapaths 4.4. Controller Finite State Machines 4.5. Microprogrammed ControlInformation contained herein was compiled from avariety of text- and Web-based sources, is intended as a teaching aidonly (to be used in conjunction with the required text, and is not to be used for anycommercial purpose. Particular thanks is given to Dr. Enrique Maflafor his permission to use selected illustrations from his course notesin these Web pages.4.1. The Central Processor - Control and DataflowReading Assignments and Exercises Recall that, in Section 3, we designed an ALU basedon (a) building blocks such as multiplexers for selecting an operationto produce ALU output, (b) carry lookahead adders to reduce thecomplexity and (in practice) the critical pathlength of arithmeticoperations, and (c) components such as coprocessors to perform costlyoperations such as floating point arithmetic. We also showed thatcomputer arithmetic suffers from errors due to fintie precision, lackof associativity, and limitations of protocols such as the IEEE 754floating point standard. 4.1.1. ReviewIn previous sections, we discussed computerorganization at the microarchitectural level, processor organization(in terms of datapath, control, and register file), as well as logiccircuits including clocking methodologies and sequential circuits suchas latches.In Figure 4.1, the typical organization of a modernvon Neumann processor is illustrated. Note that the CPU, memorysubsystem, and I/O subsystem are connected by address, data, andcontrol buses. The fact that these are parallel buses is denoted bythe slash through each line that signifies a bus.Figure 4.1. Schematic diagram of a modern von Neumann processor,where the CPU is denoted by a shaded box -adapted from [Maf01].
Reading Assignments and Exercises The datapath is the "brawn" of a processor, since itimplements the fetch-decode-execute cycle. The general discipline fordatapath design is to (1) determine the instruction classes and formatsin the ISA, (2) design datapath components and interconnections foreach instruction class or format, and (3) compose the datapath segmentsdesigned in Step 2) to yield a composite datapath. Simple datapath components include memory (storesthe current instruction), PC or program counter (stores the addressof current instruction), and ALU (executes current instruction).The interconnection of these simple components to form a basicdatapath is illustrated in Figure 4.5. Note that the register fileis written to by the output of the ALU. As in Section 4.1, the registerfile shown in Figure 4.6 is clocked by the RegWrite signal.Figure 4.5. Schematic high-level diagram of MIPS datapath from animplementational perspective, adapted from [Maf01].
Reading Assignments and Exercises A single-cycle datapath executes in one cycle allinstructions that the datapath is designed to implement. Thisclearly impacts CPI in a beneficial way, namely, CPI = 1 cycle forall instructions. In this section, we first examine the designdiscipline for implementing such a datapath using the hardwarecomponents and instruction-specific datapaths developed in Section 4.2. Then, we discover how the performance of a single-cycledatapath can be improved using a multi-cycle implementation.4.3.2. Single DatapathsLet us begin by constructing a datapath with controlstructures taken from the results of Section 4.2. The simplest way toconnect the datapath components developed in Section 4.2 is to havethem all execute an instruction concurrently, in one cycle. As aresult, no datapath component can be used more than once per cycle,which implies duplication of components. To make this type of designmore efficient without sacrificing speed, we can share a datapathcomponent by allowing the component to have multiple inputs andoutputs selected by a multiplexer.The key to efficient single-cycle datapath design isto find commonalities among instruction types. For example, theR-format MIPS instruction datapath of Figure 4.7 and the load/storedatapath of Figure 4.8 have similar register file and ALU connections. However, the following differences can also be observed:The second ALU input is a register (R-format instruction) or a signed-extended lower 16 bits of the instruction (e.g., a load/store offset). The value written to the register file is obtained from the ALU (R-format instruction) or memory (load/store instruction).These two datapath designs can be combined to includeseparate instruction and data memory, as shown in Figure 4.10. Thecombination requires an adder and an ALU to respectively increment thePC and execute the R-format instruction. Figure 4.10. Schematic diagram of a composite datapath for R-format and load/store instructions [MK98].
RegDst Deasserted: Registerdestination number for the Write register is taken from bits 20-16 (rtfield) of the instruction Asserted: Registerdestination number for the Write register is taken from bits 15-11 (rdfield) of the instruction RegWrite Deasserted: No action Asserted: Register on the WriteRegister inputis written with the value on the WriteData input ALUSrc Deasserted: The secondALU operand is taken from the second register file output (ReadData 2) Asserted: the second alu operand is thesign-extended, lower 16 bits of the instruction PCSrc Deasserted: PC isoverwritten by the output of the adder (PC + 4) Asserted: PC overwritten by the branch target address MemRead Deasserted: No action Asserted: Data memory contents designated byaddress input are present at the ReadData output MemWrite Deasserted: No action Asserted: Data memory contents designated byaddress input are present at the WriteData input RegWrite Deasserted: The valuepresent at the WriteData input is output from the ALU Asserted: The value present at the registerWriteData input is taken from data memoryGiven only the opcode, the control unit can thus setall the control signals except PCSrc, which is only set if theinstruction is beq and the Zero output of the ALu usedfor comparison is true. PCSrc is generated by and-ing aBranch signal from the control unit with the Zero signal fromthe ALU. Thus, all control signals can be set based on the opcodebits. The resultant datapath and its signals are shown in detail inFigure 4.13.Figure 4.13. Schematic diagram of composite datapath for R-format, load/store, and branch instructions (from Figure 4.12) withcontrol signals illustrated in detail [MK98].
Each functional unit (e.g., Register File,Data Memory, ALU) can be used more than once in the course of executingan instruction, which saves hardware (and, thus, reduces cost); and Each instruction step takes one cycle, sodifferent instructions have different execution times. In contrast, thesingle-cycle datapath that we designed previously required every instruction to take one cycle, so all the instructions move at thespeed of the slowest.We next consider the basic differences between single-cycleand multi-cycle datapaths.4.3.5.1. Cursory Analysis. Figure 4.15 illustrates a simple multicycle datapath. Observe the following differences between asingle-cycle and multi-cycle datapath:In the multicycle datapath, one memory unit storesboth instructions and data, whereas the single-cycle datapath requires separate instruction and data memories. The multicycle datapath uses on ALU, versusan ALU and two adders in the single-cycle datapath, because signalscan be rerouted throuh the ALU in a multicycle implementation. In the single-cycle implementation, theinstruction executes in one cycle (by design) and the outputs of allfunctional units must stabilize within one cycle. In contrast, themulticycle implementation uses one or more registers to temporarilystore (buffer) the ALU or functional unit outputs. Thisbuffering action stores a value in a temporary register untilit is needed or used in a subsequent clock cycle.Figure 4.15. Simple multicycle datapath with bufferingregisters (Instruction register, Memory data register, A, B, andALUout) [MK98].Note that there are two types of state elements(e.g., memory, registers), which are:Programmer-Visible (register file,PC, or memory), in which data is stored that is used by subsequentinstructions (in a later clock cycle); and Additional State Elements(bufferregisters), in which data is stored that is used in a later clock cycle of the same instruction.Thus, the additional (buffer) registers determine (a)what functional units will fit into a given clock cycle and (b) thedata required for later cycles involved in executing the currentinstruction. In the simple implementation presented herein, we assumefor purposes of illustration that each clock cycle can accomodate oneand only one of the following operations:Memory access Register file access (two reads or one write) ALU operation (arithmetic or logical)4.3.5.2. New Registers. As a result of buffering,data produced by memory, register file, or ALU is saved for use in asubsequent cycle. The following temporary registers are important tothe multicycle datapath implementation discussed in this section:Instruction Register (IR) saves the data output from the Text Segment of memory for a subsequent instruction read; Memory Data Register (MDR) saves memory output for a data read operation; A and B Registers (A,B) store ALU operand values read from the register file; and ALU Output Register (ALUout) contains the result produced by the ALU.The IR and MDR are distinct registers because someoperations require both instruction and data in the same clock cycle.Since all registers except the IR hold data only between two adjacentclock cycles, these registers do not need a write control signal. Incontrast, the IR holds an instruction until it is executed (multipleclock cycles) and therefor requires a write control signal to protectthe instruction from being overwritten before its execution has beencompleted.4.3.5.3. New Muxes. we also need to add newmultiplexers and expand existing ones, to implement sharing offunctional units. For example, we need to select between memoryaddress as PC (for a load instruction) or ALUout (for load/storeinstructions). The muxes also route to one ALU the many inputs andoutputs that were distributed among the several ALUs of thesingle-cycle datapath. Thus, we make the following additional changesto the single-cycle datapath:Add a multiplexer to the first ALU input, tochoose between (a) the A register as input (for R- and I-format instructions), or (b) the PC as input (for branch instructions). On the second ALU, the input is selected by afour-way mux (two control bits). The two additional inputs to the muxare (a) the immediate (constant) value 4 for incrementing the PC and(b) the sign-extended offset, shifted two bits to preserve alighment,which is used in computing the branch target address.The details of these muxes are shown in Figure 4.16.By adding a few registers (buffers) and muxes (inexpensive widgets), we halve the number of memory units (expensive hardware) and eliminatetwo adders (more expensive hardware).4.3.5.4. New Control Signals. The datapathshown in Figure 4.16 is multicycle, since it uses multiple cycles perinstruction. As a result, it will require different control signalsthan the single-cycle datapath, as follows:Write Control Signals for the IR andprogrammer-visible state units Read Control Signal for the memory; and Control Lines for the muxes.It is advantageous that the ALU control from thesingle-cycle datapath can be used as-is for the multicycle datapathALU control. However, some modifications are required to supportbranches and jumps. We describe these changes as follows.4.3.5.5. Branch and Jump Instruction Support.To implement branch and jump instructions, one of three possible valuesis written to the PC:ALU output = PC + 4, to get thenext instruction during the instruction fetch step (to do this, PC + 4is written directly to the PC) Register ALUout, which stores thecomputed branch target address. Lower 26 bits (offset) of the IR,shifted left by two bits (to preserve alginment) and concatenated withthe upper four bits of PC+4, to form the jump target address.The PC is written unconditionally (jump instruction)or conditionally (branch), which implies two control signals - PCWriteand PCWriteCond. From these two signals and the Zero output of theALU, we derive the PCWrite control signal, via the following logic equation:PCWriteControl = (ALUZero and PCWriteCond) orPCWrite, 2ff7e9595c
Comments