What would be a good career choice for a new grad who has job offers in CPU design and GPU design (front end RTL) groups?

Question

Eric Backeberg · Answer

The field is Computer Engineering [1]

The degree you need is at least a Bachelors in Computer Engineering however many universities combine it with computer sciences so that you have a degree in Computer Sciences and Engineering.

CPU and GPU design however is at the very top of the field as it is the most complex and difficult of the Computer Engineering specialities. Most of the people working in the logic processor part of hardware engineering have their doctorates and decades of experience usually having worked at all three of Intel, nVida and AMD.

1. Computer engineering - Wikipedia [ https://en.wikipedia.org/wiki/Computer_engineering ]

Anonymous · Answer

I’ve known quite a few people who work or have worked on GPUs at AMD/ATI, Apple, Intel, and NVIDIA.

The short answer at the present time: get a graduate degree, mostly likely a PhD, in computer architecture from one of the top universities in computer engineering.

Because of the extreme cost of fabbing a silicon processor these days, only companies with deep pockets can afford to do so, which means they hire very few people. Graduate students at the top programs learned about the physics and the core principles during undergraduate study, then get the chance to experiment with ideas with like-minded people and learn about the history of silicon computing during graduate study. That knowledge and experience is probably not obtainable any other way now.

Also, if you take any side trips, such as I did into compilers, you will probably be working on that and not computer architecture.

Manikanta Mashetti · Answer

In my MS, I had done a project related to RISC Processor. I had implemented this processor using System C. Which had given me so much of confidence and knowledge.

1. I had designed a simple compiler using Perl.
2. I had implemented Integer, Floating Point Instructions.
3. To implements Mul, Div instructions I had analyzed so many algorithms in both integer and floating.
4. One of the important thing in processor architecture is Branch Prediction and Pipe lining, My processor was basic 5 stage processor.
5. Coming to Branch prediction, Two Bit Branch predictor, Correlating branch predictor, Tournament(Hybrid) Branch predictor.
6. Later, I had also implemented DSP related instructions.
Why I am telling all this stuff? Simple, In my first year of course we had Processor architecture when I was reading the subject seems like every thing is perfect. But once I started my project in second year, real learning starts.

my intention is if you want to learn, and master on computer architecture start coding simple processor and start experimenting on it.

Anonymous · Answer

I haven’t seen anyone amongst former or current colleagues at the aforementioned companies call themselves a “performance architect.” They are just hardware architects: if they aren’t able to fine tune performance and power, they don’t have the background to call themselves “architects.” It’s like a racing driver calling himself a “performance racing driver.”

If you want a position as a hardware architect, then you should go to a top graduate school in that area, probably a PhD. The field is shrinking because the number of designs is shrinking. It’s one of the reasons I shifted in graduate school.

If you want to work on software performance, you will need to have a good understanding of hardware and compilers. “Good” in this case means being talking the same language as the hardware engineers and understanding the effect of microarchitecture changes.

Terry Lambert · Answer

Unless we are talking about animation or ray tracing, most graphic design tasks are in running image creation for single images. Even for animation, in the design phase, you are merely creating key frames.

So neither a great deal of CPU nor a great deal of GPU, is a general requirement, so it won’t matter.so [ http://matter.So ] pick something balanced, unless you have another reason for unblancing the relationship.

Typically, overpowering the GPU is only useful if it has separate video RAM, and is partly or wholly independent of system RAM, so there’s no competition there. Otherwise, you are going to be paying the MESI cache coherence cost between the parts, no matter what, so they’d better be able to keep up with each other.

Sai Krishna Manapragada · Answer

Dont limit yourself to the block that you are working on. It limits you to a great extent. Start understanding the related blocks. Keep growing your knowledge.
Debug, debug and more debug. Even if you don't know the system, even if you don't have a clue about the language(perl, python, uvm anything). You will get better and will definitely have a better understanding. 
Speak to the experienced guys, their experiences, the errors that they made, the challenges they faced.. Keep an open mind to suggestions.. There is always a better way of getting things done.
Experience is invaluable. Keep learning. Never forget to learn.
I worked with an Engineer with 27 years of experience and is still looking for inputs.  That's one person to be like.. 
All the best

Brent Eads · Answer

A master's in electronic engineering would be a good start along with an internship or two with a chip designer like Intel, ATI or Nvidia.

This is not a cheap cert kind of industry by any stretch of the imagination.

Mayank Srivastava · Answer

Let’s find the answer to this question :

How processor, assembler, and programming languages work

You might be wondering about how your computer works: what happens when you write a program and then compile it? What is assembler and what is the basic principle of programming in it? This tutorial should clarify this for you, it’s not indented to teach you assembly programming itself, but rather give you the needed basics to understand what’s actually going on under the hood. It also deliberately simplifies some things, so you’re not overwhelmed by additional information. However, I assume that you have some knowledge in high level programming (C/C++, Visual Basic, Python, Pascal, Java, and tons more…).

Also I hope that the more skilled guys will forgive me for simplifying a lot of things here, my intention was to make the explanation clear and simple for someone who doesn't have a clue about this topic.

Note: I will be very grateful for any feedback on this. It’s difficult to write explanations for people who don’t know much about the topic, so I might’ve omitted some important things or didn’t clarify something enough, so if something is unclear, don’t worry to ask.

How does the processor (CPU) work?

You might know that the CPU (Central Processing Unit, or simply processor) is the “brain” of the computer, controlling all other parts of the computer and performing various calculations and operations with data. But how does it achieve that?

Processor is a circuit that is designed to perform single instructions: actually a whole series of them, one by one. The instructions to be executed are stored in some memory, in a PC, it’s the operating memory. Imagine the memory like a large grid of cells. Each cell can store a small number and each cell has its own unique number – address. The processor tells the memory address of a cell and the memory responds with the value (number, but it can represent anything – letters, graphics, sound… everything can be converted to numerical values) stored in the cell. Of course, the processor can tell the memory to store a new number in a given cell as well.

Instructions themselves are basically numbers too: each simple operation is assigned its own unique numeric code. The processor retrieves this number and decides what to do: for example, number 35 will cause the processor to copy data from one memory cell to another, number 48 can tell it to add two numbers together, and number 12 can tell it to perform a simple logical operation called OR.

Which operations are assigned to which numbers is decided by the engineers who design a given processor, or it’s better to say processor architecture: they decide what number codes will be assigned to various operations (and of course, they decide other aspects of the processor, but that’s not relevant now). This set of rules is then called the architecture. This way, manufactures can create various processors that support a given architecture: they can differ in speed, power consumption, and price, but they all understand the same codes as same instructions.

Once the processor completes the action determined by the code (the instruction), it simply requests the following one and repeats the whole process. Sometimes it can also decide to jump to different places in the memory, for example to some subroutine (function) or jump a few cells back to a previous instruction and execute the same sequence again – basically creating a loop. The sequence of numerical codes that form the program is called machine code.

What are instructions and how are they used?

As I already mentioned, instructions are very simple tasks that the processor can perform, each one having its unique code. The circuit that makes up the processor is designed in a way to perform the given operations according to the codes it loads from the memory. The numeric code is often called opcode.

The operations that the instructions perform are usually very simple. Only by writing a sequence of these simple operations, can you make the processor perform a specific task. However, writing a sequence of numeric codes is quite tedious (though that’s how programming was done long ago), so the assembly programming language was created. It assigns opcodes (the numeric code) a symbol – a name that sort of describes what it does.

Given the previous examples, where number 35 makes the processor move data from one memory cell to another, we can assign this instruction name [code ]MOV[/code], which is a short for MOVe. Number 48, which is the instruction that adds two numbers together gets the name [code ]ADD[/code], and 12, which performs the OR logical operation, gets the name [code ]ORL[/code].

The programmer writes a sequence of instructions – simple operations that the processor can perform, using these names, which are much easier to read than just numeric codes. Then he executes a tool named assembler (but often the term “assembler” is used also for the programming language, though technically it means the tool), which will convert these symbols to the appropriate numeric codes that can be executed by the processor.

However, in most cases, the instruction itself isn’t sufficient. For example, if you want to add two numbers together, you obviously need to specify them, the same goes for logical operations, or moving data from a memory cell to another: you need to specify the address of the source and the target cell. This is done by adding the so-called operands to the instruction – simply one or more values (numbers) that will provide additional information for the instruction needed to perform a given operation. The operands are stored in the memory too, along with the instruction opcodes.

For example, if you want to move data from a location with address 1000 to a location 1258, you can write:

Hide Copy Code

[code]MOV 1258, 1000
[/code]The first number being the target address and the second the source (in assembly, you usually write the target first, and the source as the second one, it’s quite common). The assembler (the tool that converts the source to the machine code) stores these operands too, so when the processor first loads the instruction opcodes, which will tell it that it must move data from one location to another. Of course, it needs to know from which location to move to what destination, so it will load the operand values from the memory too (they can be at addresses right after the instruction opcodes), and once it has all the necessary data, it will perform the operation.

Small example

Let’s look at some short code and describe what it does. Please note that it's pseudocode, it's not made for a specific architecture or language and various symbols can differ, the principle however, remains the same.

Hide Copy Code

[code]MOV A, 2000
LOOP:
ADD A, #5
JNL A, #200, LOOP
MOV 2001, A
[/code]The first instruction will move the number from the memory cell with address 2000 to a register A – it’s a temporary location, where the processor stores numbers. It can have many registers like this. The second line contains something called a label: it’s not an instruction, it’s simply a mark in the source code that we may use later (you’ll see how).

On the third line, there’s an [code ]ADD[/code] instruction, which adds two numbers together. The operands are register A and number 5 (the # mark before tells the assembler that it’s number five, not a number in the memory cell with address 5). And remember? We stored the value from memory location 2000 in the A register, so whatever the value is, this instruction will add the number 5 to it.

The following instruction is called a conditional jump: the processor will test some condition and based on the result, it will jump or not. In this case, the condition is whether a given number is not larger than another one ([code ]JNL[/code] = Jump (if) Not Larger). The number being compared is the number in register A, with the number 200 (again, mark # means that it’s a direct number, not a number from the memory location with address 200). In this case, the number in A is smaller than 200 (thus not larger than 200 – condition is true), the processor will make a jump at the instruction specified by the third operand, and this is where our label comes in: the assembler tool (the translator) will replace “[code ]LOOP[/code]” with the memory address of the instruction right after this mark.

So if the number is smaller, the processor will jump back to the instruction [code ]ADD[/code] and again add value 5 to the number A (which is already larger from the previous calculation) and then get back to the [code ]JNL[/code] instruction. If the number is still smaller than 200, it will jump back again; however, if it is larger, then the condition won’t be true anymore, so no jump occurs and the following instruction gets executed. This one moves value from register A to the memory cell with address 2001, basically storing the resulting number there. It’s important to add, that the memory cell with address 2000 still contains the original value, because we created a copy of it in register A, we didn’t modify the original.

This piece of code doesn’t really have much of a purpose; it’s simply for demonstration and also for some hypothetical architecture. Real-world programs are composed of hundreds, thousands, even hundreds of thousands of instructions.

Architectures and assembly languages

I already mentioned the term architecture before: it describes features of certain processors. It describes what simple operations the processor can perform (some may be able to perform only a dozen of them, some hundreds of various operations), and what opcodes each instruction has. It also specifies a lot of other things: what and how many registers (small storage places directly in the processor itself, where the programmer can temporarily store data) it has, how it can communicate with other chips and devices, like memory, chipset, graphics card, and other features of its function.

This means that every processor has its own assembly language, because the instructions it has are different. Thus, assembly language (or simply assembler, though it’s technically not correct) is not just one language, it’s a whole set of languages. They’re all quite similar, but differ in what instructions are there, what are the operands and some other features specific to the processor. However the basic principle is the same (unless it’s one of my WPU experimental processors :-) ) among them, so if you understand principle of one assembler for a given architecture, learning others will be a cinch.

So it’s important to understand: assembly language is always meant to be used with a specific architecture. For example, most personal computers use an architecture called x86, or in the case of 64-bit systems and applications, its extension x64, so if you wanted to program for this architecture, you would use the x86 assembly language. Many mobile devices use an architecture called ARM, so if you have programmed these processors in assembler, you would use the ARM assembly language. If you wanted to program some old console, like Sega Genesis, you would use the 68000 assembly language, because it uses the Motorola 68000 processor, and so on. There are hundreds of various architectures for various purposes.

Also, like I said, there are a lot of processors on the market with varying speeds, price, and power consumption, but many of them support the same architecture – thus programs written in the given assembly language will work on them, they'll just run faster or slower.

However, programs created for one architecture generally won’t work on another one, because the processor is simply different: the opcodes are different, the supported instructions and other features are different, so the machine code (a program – set of numeric codes) for x86 architecture would be gibberish for the ARM architecture. This also means when you write a program in assembler for one processor architecture, it won’t work on another one: you would need to rewrite it completely into assembly language for a different architecture.

Need for high level programming languages and compilers

There were two big pressing issues that led to the high level programming languages that you most probably already know. First, creating complex programs requires dividing them into a lot of simple instructions, so to achieve more complex actions, you need to write a lot of instructions: this is both tedious and time consuming, not to mention that it’s more difficult to understand. The second issue was already mentioned: a program written for one architecture won’t work on another one without a complete rewrite. High level languages solve both these problems.

Complexity of programs

Let’s imagine that you want to perform a more complex calculation, for example, you want to calculate the result of A = 2 + ( 7 – 3 ) * 2. However, the processor doesn’t support anything like that, it can only perform very simple operations. So if you want to write code in assembly, you need to split this calculation into simple operations that the processor supports. For a mathematic expression, this is done the same way you would do it if you were calculating the expression manually in math class, for example: first you need to calculate the value in the parentheses (subtract 3 from 7), then multiply the result by 2, and finally add it to number 2. The result will be stored in register A. So the assembly code would look like this (the “;” starts a comment - not part of the code, just a remark of what it does):

Hide Copy Code

[code]SUB #3, #7  ; Subtract 7 from 1 and store the result in register A
MUL A, #2   ; Multiply value in register A (containing the result of previous operation)
            ; by two and again, store the result in register A
ADD #2, A   ; Add the result of previous operation (in register A) to the number 2
            ; and store it in the register A, so A now contains the result
[/code]Of course, you’ll rarely use fixed numbers in calculations, you’ll rather calculate with values from the memory, so let's complicate the whole process with the following change to the equation: @250 = @200 + ( @201 - @202 ) * @203. Here @(number) means “at address” – the number stored in the memory cell at the given address. To complete the calculation, we need to load values from memory, because the processor doesn’t allow calculations with numbers at the given memory addresses directly, however it provides another register B.

Hide Copy Code

[code]MOV B, 202 ; Move the value from memory address 202 to register B
MOV A, 201 ; Move the value from memory address 201 to register A
SUB A, B   ; Subtraction (@201 - @202) and store the result in A
MOV B, 203 ; Move the value from memory address 203 to register B
MUL A, B   ; Multiply the value from previous calculation with number at the address 203 stored in B
MOV B, 200 ; Move the value from memory address 200 to register B
ADD A, B   ; Add value in A (( @201 - @202 ) * @203) to B (@200) and store the result in A
MOV 250, A ; Store the result in the memory cell with address 250
[/code]As you can see, even simple expressions can get complicated and will require several lines of code, which is quite tedious. Not to mention that it’s quite difficult from the code to understand what it is actually doing, unless you explain it in the comments. But unfortunately, there’s no way around, it’s simply how the processor works. You can imagine that with more complex code, the number of instructions and tediousness would increase rapidly.

Another problem is, the values you’re working with (you can basically consider them variables) are just numbers (addresses), which are not exactly easy to deal with. You can assign the addresses some names, but that just delays the problem a bit: you still need to say that address 204 will be known under name [code ]MYVARIABLE[/code] and if the number of variables increases, it will quickly get problematic, although assigning exact addresses is usually automated. Not to mention you might use an address as a specific variable only for a short while and then reuse it as another, but you also have to make sure that both (or even more) usages won’t collide.

Where the compiler comes in

Okay, so here’s a question: if you can split expressions and tasks into a series of simple instructions and if you can assign memory locations for variables, why can’t it be done by a program? And that’s exactly what the compiler does. The programming language specifies what kind of statements you can write and how, and the compiler must support them. So you can simply write the following code (it’s C-like code):

Hide Copy Code

[code]int a, b, c, d, e;
a = 2;
b = 7;
c = 3;
d = 2;
e = a + (b - c) * d;
[/code]When you compile this code, the compiler will analyze (parse) this code and it will find that you want five variables. You don’t have to decide which memory cells will be assigned to these variables: it’s all handled for you. For example, the compiler might decide that contents of the variable named “[code ]a[/code]” will be stored in a memory cell with address 200, “[code ]b[/code]” in 201, and so on. The compiler keeps track of these assignments, so wherever you use the given variable, it will make sure that the proper memory address is used. In reality, the process is often a bit more complex than this, but the principle remains the same.

In the example code, there are a few value assignments, starting with “[code ]a = 2;[/code]”. The compiler will read this and according to the rules of the programming language, this means, that the variable is assigned the value 2. The compiler knows which memory address corresponds to the variable named “[code ]a[/code]”, so it will generate the proper instructions for you: remember, the processor doesn’t understand expressions like “a = 2;”, it can only work with simple instructions. But it’s the compiler’s job to convert these high level statements into instructions that the processor understands:

Hide Copy Code

[code]MOV 200, #2  ; Move number 2 to the memory location 500, which corresponds with variable "a"
MOV 201, #7  ; b = 7
MOV 202, #3  ; c = 3
MOV 203, #2  ; d = 2
[/code]This is hopefully simple enough; each assignment corresponds to a processor instruction (I’ve written them in assembly language, the compiler will of course generate the appropriate numeric codes for each instruction – the machine code). However, when it comes to the last statement, which assigns the result of the expression “a + (b - c) * d” to the variable “[code ]e[/code]”, it can’t be done using a single instruction as you’ve seen before. However, all you need to do is to write this expression and the compiler will read it and do the splitting into a series of simple instructions itself, without you even knowing about it (until now at least :-) ). For example, it might generate the following instructions:

Hide Copy Code

[code]MOV B, 202 ; Move the value from memory address 202 (variable "c") to register B
MOV A, 201 ; Move the value from memory address 201 (variable "b") to register A
SUB A, B   ; Subtraction (b - c) and store the result in A
MOV B, 203 ; Move the value from memory address 203 (variable "d) to register B
MUL A, B   ; Multiply the value from previous calculation with value of variable "d" stored in B
MOV B, 200 ; Move the value from memory address 200 (variable "a") to register B
ADD A, B   ; Add value in A (( b - c ) * d) to B (a) and store the result in A
MOV 250, A ; Store the result in the memory cell with address 250 (variable "e")
[/code]I think it needs no explaining that it’s much easier to simply write “e = a + (b - c) * d” instead of a series of instructions and the same principle applies to everything. A high level programming language allows you to express the actions to be performed in a more clear, easier, and understandable manner, and the compiler will take care of converting this into a series of simple instructions the processor understands, and will handle all other details for you. This is called abstraction and solves the program complexity problem: you can write and manage much more complex programs, because you don’t have to bother with all the details: they’re taken care of for you automatically.

It might be important to mention how some basic programming constructs are handled. For example, the “[code ]if[/code]” statement. Let’s consider the following C code:

Hide Copy Code

[code]if(a %3E 2)
    b = 3;
else
{
    b = 5;
    c = 8;
}
a = 8;
[/code]The processor doesn’t understand what the “[code ]if[/code]” statement is, however it has a conditional jump instruction: it will jump to another instruction if a condition is true. So this fragment will be translated to the following assembly code:

Hide Copy Code

[code]MOV A, 200    ; Move the value of variable "a" (address 200) to register A
LGR #2        ; If value in register A is larger than number 2, store number 1
              ; in the register A, if not, store number 0 in register A
JZ ELSE       ; If value in A (result of the comparation) is zero,
              ; jump at the instruction after the "ELSE:" label,
              ; instead execute the following instruction
MOV 201, #3   ; Move number 3 to memory location 201 (variable "b"), b = 3
JMP END       ; Skip to the "END:" label so the instructions of the else clause are not executed
ELSE:
MOV 201, #5   ; b = 5; 
MOV 202, #8   ; c = 8;
END:
MOV 201, #8   ; a = 8
[/code]The same goes for loops, except the jump instruction causes to jump back in the sequence, so a portion of the code gets repeated. When programming in a high level language, you don’t have to bother how exactly the loop is constructed using the jump instruction, the processor can actually have several of them, each one having a different condition: the compiler will handle this arrangement for you, as well as choose the appropriate jump instruction and do additional work so the conditional jump can be performed: in this example, we assumed that the processor doesn’t have a conditional instruction that would compare which number is larger: instead, it has a separate instruction to test this, so the compiler uses the instruction to compare two numbers first and then uses the result with the appropriate conditional jump instruction.

Need for the assembler nowadays

You might be wondering: if the compiler can handle all these things for you, what’s the point of knowing assembler today? There are several answers: first, the compiler might not always generate optimal instructions: some actions can be done using fewer instructions in a less standard way that the compiler doesn’t know of. This is a problem when you need to squeeze every bit of performance; in such cases, you can write instructions for the performance critical parts yourself, ensuring that it works exactly the way you want it to.

This might be even a bigger problem when programming for small embedded devices with limited resources, where you can’t simply afford any overhead (more instructions that are actually needed and suboptimal ways to solve things). Another reason is limitations of the compiler: you’re limited only by what it supports, if you want to use some features of the processor that the compiler can’t generate instructions for, for example, new special instructions, you’ll need to write them yourself.

Knowledge of assembly is an absolute must if you want to analyze existing software, hack (alter its behavior) or crack it. As you already know, program is composed of series of simple instructions – numeric codes that represent various actions. It’s easy to disassemble an existing program when you don’t have its source code: the numeric codes are simply replaced with their appropriate names, resulting in an assembly language code, so if you want to analyze and modify them, you must know assembly language.

It’s much more difficult to decompile the program – convert it back to its high level source code: this needs extensive analysis of the instructions and their structure, and the resulting source code will be still very far from the original: important things like names of variables, functions, and comments are lost during compilation (not necessarily for all languages), because they’re simply not needed by the processor: all it needs is memory address, which is just a number.

Portability

The second major problem of assembly programming is portability: to transfer your program to another platform with a different processor architecture, you need to rewrite it completely in the assembly language for the target platform. Using a high level language solves this problem quite easily. The code in the high level language is usually platform independent: it’s the compiler that generates the appropriate instructions, not you.

So if you want your code to run on a PC with x86 architecture, you give the sources to a compiler that generates instructions for x86. If you want to make binary (machine code) for a mobile device with ARM architecture, you give the same source code to an ARM compiler and it will generate instructions for that architecture, without you needing to do anything.

This of course requires that a compiler exists for the given architecture; if there is no compiler for a particular architecture, then you’ll be left with assembly programming, unless you write the compiler yourself.

Interpreted languages

So far, we only dealt with something that’s called native code: languages that create native code result in instructions that are directly executed by a given processor. If you create a binary file (containing these raw instructions for a given processor), it will only work on a given architecture; if you want to use it on another, you’ll need to compile it for that architecture: generate the appropriate machine code that the processor of a given architecture understands.

However, there exists something that’s called an interpreted language, which makes portability much easier. I will mention this only briefly, since the topic can be elaborated into a long article on its own. With an interpreted programming language, the source is left as it is, or it is compiled into a “universal” assembly code (that’s what happens with Java – the resulting universal assembly code is called bytecode). If you want to run such a program, you need an interpreter: it’s a program in native code – something that the processor understands directly, that can read this universal code and translate it into instructions for the target architecture on the fly – as the program is run.

The advantage of this approach is easy portability, safety, and flexibility: you can write your program once and then it will run on every architecture where the interpreter for the given language is available, without having to change a single thing about your program. Because the interpreter is in control of what the program can do, safety is also increased, because it can choose to block certain actions, which is much more difficult with native code, if not impossible. You can also test and modify your program quickly without having to compile it every time.

One of the major downsides is reduced speed: for example, in case of an assignment like “a = 5”, an interpreted language might need the processor to execute even a few dozen instructions, which will read this statement, decide what it means, and then finally do it, while with a compiled language (resulting in native code), a single instruction can often handle this task.

Sougata Bhattacharjee · Answer

As a RTL designer the most primary skills required are Digital electronics and any one of the HDL language like VHDL or Verilog.Apart from that complete understanding on ASIC and FPGA flow is necessary.

However the following books are essential as a primary requirement for learning RTL design:-

* “A VHDL Primer” by Jayaram Bhasker.
 * “Digital Design:Principles and Practices” by John F.Wakerly
 * “Digital Design” by M.Morris Mano
 * “Verilog HDL” by Samir Palnitkar
 * “SystemVerilog for Design” by Stuart Sutherland
 * “Application Specific Integrated Circuits” by John Smith
Apart from these books mentioned above you can also refer sunburst Design papers which are of immense help in learning the coding guidelines,RTL coding Techniques,Synthesis and detailed analysis of many more complex topics.

Besides these you can refer perlmonks website for the knowledge on scripting language.

Lawrence Stewart · Answer

Only if you want to be a good CPU designer.

Not being very familiar with coding would bar you from any architectural role in CPU design.

Not being able to code would eliminate you from CPU logic design, which is done in verilog or vhdl these days

Not being able to code would prevent you from any useful role in design verification or simulation.

What’s left? You might be able to help with mechanical engineering questions like heat transfer or socket design, or the adhesives that hold a CPU together.

You might be able to do device design, that is really physics though, and far removed from the CPU.

In the old days, you could be a layout designer without programming, but I don’t think that is true any more.

Lawrence Stewart · Answer

Well on balance I think so, but there are issues.

If you are looking to be a CPU designer, then doing some FPGA designs will be have some benefits

* learning one or more RTL (register transfer languages) and HLS (high level synthesis) languages
 * Learning how formal interfaces for hardware work
 * learning how to rexpress your ideas in appropriate languages
 * Learning one or more CAD suites. Vivado and Quartus (the CAD for Xilinx and Intel FPGAs) are different and the same and awful and powerful, which is pretty much what the CAD suites for custom ASICs are like.
 * Learning about timing closure
 * You can run designs on real hardware, which will be a different sort of experience than running on simulators.
All that being said, FPGAs are quite a bit slower than full custom designs, and the parts have a lot of capabilities that it will take discipline to ignore while you are designing a CPU.

Real CPU design teams are not a single person anymore, given their size and complexity, so you find specialists in architecture, microarchitecture, logic design, physical design, verification, functional simulation, circuit simulation, cycle accurate simulation, CAD tooling, and I am sure a bunch of other stuff.

So a CPU design career is quite a broad brush.

Ramdas · Answer

I have been working in CPU/microprocessor verification for last 10+ years in Bangalore across few companies and I agree that computer architecture is a very interesting domain to work on.

In Bangalore, there is big presence of CPU/GPU design and verification in companies like Intel, IBM, AMD, ARM, Qualcomm, Nvidia, APM and few other startups as well. Some of the bigger companies do have presence in both design and verification while some companies has design mostly done at head quarters (US or UK) while having bigger presence in verification.

As part of your course , keep doing extra learning in the field of computer architecture

1. Learn some Instruction set architecture (preferably ARM) which is popular. Plenty of online material available (Some include lecture like these here youtube lectures [ https://youtu.be/7LqPJGnBPMM ] )
2. Keep reading about latest innovations happening in field of computer architecture, details about latest CPU/GPU arriving in market from companies like Intel/AMD/IBM/ARM etc (Easy way is to follow some relevant websites like Anandtech [ http://www.anandtech.com ] through twitter )
3. Follow trends in design and verification - Learn languages like SystemVerilog, verification methodologies like UVM , and be good in programming. Do some projects extra on top of your courses/assignments (Following online courses might help: Verification Excellence [ http://verificationexcellence.in/online-courses/ ] )
4. Find some internships along with your course as it nears completion in one of these companies (Also refer Where can I find internships? [ https://www.quora.com/Where-can-I-find-internships ] )
Follow your passion, work towards it and success will follow:

Sourav De · Answer

Designing a GPU is an extremely difficult process and probably the one of epitome field of electronics. Before you jump in to GPU designing you probably will require extensive theoretical and practical knowledge in FPGA, Embedded electronics, Chip fabrication, microprocessor with architectural knowledge. Also knowledge of thermal management or efficient cooling, aesthetics etc are also required.
The best way to get into the field, assuming you are from electronics engineering background is to apply for the vendor companies like Nvidia, AMD, Red Rocket etc. Or go for manufactures like XFX, PowerColor, MSI, Asus but these will be more from production perspective than designing, but it will add valuable experience to your resume which you can use later on.
If you are looking for a specific book to jump on I will recommend this one: http://tinyurl.com/y7fby3gq
Wish you all the best!

Ian Heggie · Answer

As my brother says, you can be a big fish in a small pond or a small fish in a big pond!

If you are wanting to work where the focus is on being multi skilled, then stick with the small ponds (small, medium sized companies), where they only need one, maybe two IT people working on their projects - you will have the opportunity and expectation of being able to handle the project basically from inception right through to deployment and ongoing support.

Be honest with yourself with what you are better and what you are worse than average on, and look for situations that fit your skill set - this will make both you and your clients happier. Personally I am stronger on the back end than the front end because I have more of an engineers mindset than an architects (I jokingly blame this on being the son of an engineer, the son of an engineer). Being someone who cares more about the product being right than it being prettied up, If a client also needs the artistic polish, then they engage someone else for that is good at that aspect. In my case that means I can certainly work on the functionality and robustness of the front end, but I leave customising the CSS styling and layout choices to someone else.

If you work in both the front and back end, then you will of necessity be more of a generalist than someone who focuses on just one aspect. It will require more from you because you generally wont use your whole span of ability and skill on any one project, compared to someone who is part of a large team and so has enough work of similar kind coming through that they can just focus on the same technology.

Anonymous · Answer

For long time all digital logic is designed using programming languages Verilog and VHDL, commonly known as HDL (hardware description language).

For example if we have to multiply two registers (values) in hardware following code is written:

[code]always @(posedge i_clk)
		result %3C= in_one * in_two;
[/code]Above code will be by compiler converted, at very end, into transistors design.

Wanna see real code for a 32 bit CPU?
Navigate here to see RISC-V files:

https://github.com/ultraembedded/riscv
Folder core/riscv has source files. For example file riscv_alu.v is ALU (arithmetic and logic unit) implementation.
For example code for addition:

[code] `ALU_ADD : 
 begin
 result_r = (alu_a_i + alu_b_i);
 end
[/code]Do not know how much are in programming but above is like many other languages with specifics for hardware design where things happen in parallel as opposite to software where process is serialized.

Guy Alster · Answer

As FPGA's become cheaper and easy to integrate with, some companies will use them to speed up (in HW) processes that used to be done in software (see link below):
Catapult - Microsoft Research [ http://research.microsoft.com/en-us/projects/catapult/ ]

For tasks like these, which will require understanding both worlds, there will be a great advantage for multidisciplinary engineers such as those that your title asks about. The nice thing about being multidisciplinary is that regardless of the trends in technology, you can always scope yourself down to which ever field you find most interesting or whichever is the "hottest" at any given time. In essence what I'm trying to say is that having a wider skill set and knowledge is never a problem, its the opposite that you should be worried about.
Hope this helps.

Jonathan Kang · Answer

I've found this varies significantly depending on the group and company you work for. There are strikingly different environments and work cultures that are carried over from the history of the design group as well as management. However, I'll try to generalize:

Day-to-day:

Other than the obligatory Facebook/Fark/[insert favorite time waster], the vast majority of the time is spent staring at simulation waveforms and figuring out what went wrong. Like most engineering jobs, debugging takes the most time. A CPU generally takes 2-4 years to make with various phases that will bring about different types of day-to-day work.

During initial micro-architecture development, it's mostly a lot of meetings and a lot of data collecting. Data from performance models -- cycle accurate models written in C++ meant to simulate the per-cycle performance -- must be collected to get a rough gauge of what the target performance is like. Data from previous test-chips and circuit models must be collected to get a rough idea of how fast various cells (AND, OR gates, compressors, multiplexers, flops, etc.) will perform under various conditions. Data from management about maximum die-size -- which is the biggest factor in cost -- as well as power requirements.

After that, a rough draft of the micro-architecture is created; the CPU is then broken down into various natural partitions -- the execution unit, floating point unit, load/store pipeline, fetch and decode, etc. During this time, each designer's handed their own partition and goes off to create more detailed micro-architecture. During this phase, the day-to-day consists mostly of reading papers on either ACM or IEEE to study what's been done before and deciding if you can make improvements on it or adapt it to suit your performance/power/area needs. Data collected from previous designs help a lot here as they give a far more realistic idea of what to expect in the final implementation.

Then comes the actual coding phase. Depending on the workflow -- it varies per company -- this will likely involve a lot of scripting; there's a saying that Perl is the most popular CAD tool. This is also the time to run synthesis and timing analysis on your own partition. This kind of early feedback isn't necessarily very accurate but it gives some idea of any major problems in the logic in terms of frequency/power/area.

Then comes a long long long while of debugging. A well established CPU group will have had verification engineers make a robust and thorough random simulation environment at this point -- it generates random sequences of instructions and checks the results on either an instruction-by-instruction boundary or a cycle boundary. From this point on, simulations are run 24/7. Anything that fails will be saved off and added onto the list of things the designer has to look at.

Then comes tape-out and debugging on the lab bench. There's generally a ~2-3 month window of waiting for silicon to come back. During this time, an emulator can be created from FPGA's. This is also the time when an operating system will be put onto the design and a boot is attempted. Since most FPGA's allow in-chip probing, this helps a lot in debugging. The day-to-day here is a lot of time on the lab bench and a lot of angry emails with the OS vendor.

Qualifications:

Patience. CPU design takes a long-ass time; longer than most projects in engineering outside of aerospace. A degree with a lot of emphasis on computer architecture and logic design helps get you in the door. Good intuition and general interest on making better designs will keep you sane. Good abstract modeling skills -- remembering it's not code, it's hardware -- is a must-have. Good craftsmanship is required. Any small improvements made will manifest itself; there's nothing that isn't worthwhile to optimize.

Joel A. Seely · Answer

Yes, it's a dead end. If you enjoy creating hardware, RTL design targeting FPGAs is still a good choice (although there is a huge amount of effort here to make it more like creating software than hardware). But if you actually think you're going to join a company to design and make chips, forget about it. Why? First, there are fewer and fewer companies designing new chips. This is true primarily for economic reasons. At the latest node (7 nm at TSMC) it costs tens of million of dollars to create a new chip which means there needs to be markets of a hundred million dollars or more to make that chip worthwhile. How many hundred million dollar hardware plays are there? Take a look at what venture capitalists are funding in the way of new startups and you'll quickly come up with the answer: pretty close to zero. Next, going back to that 7nm thing, how many silicon atoms is that? Nearest neighbor distance is 0.235nm, so roughly 28 atoms (or fewer depending on lattice orientation). This implies that there's not much room left in Moore’s law. And finally, assume you did get a job at a company that makes chips (of which there are fewer and fewer these days due to mergers and acquisitions). Do you think you'd be doing actual design work? Unlikely. You'd most likely start on the verification team until you proved yourself. If you were really lucky you might then get to do some trivial circuit that someone else sketched out on a whiteboard. It will take years before you finally get to do some real design work. However, if you did choose this path and pay your dues and wait all those years you'd be in a pretty sweet spot because all the current designers are middle aged or older and will be retiring in greater numbers in the coming years, so you might find yourself as the last remaining chip design guru! Too bad about that Moore’s law thing though.

Robert Miles · Answer

I haven’t designed a CPU, but have helped design an add-on to be added to the same chip.

I’d expect a CPU designer to be part of a fairly large team, with most of them designing specific sections of the CPU, but a few deciding how to divide the design into suitable sections and a few working on how to connect the various sections.

Then there would be a second group, working on how to convert the logic design into a physical layout packing the various sections onto the chip without too much speed loss caused by long connections.

Anonymous · Answer

Absolutely not a dead-end career — Moore’s Law/Dennard Scaling is at an end, and the only path to greater functionality is through specialization — that is, the construction of specialized, application-customized hardware, i.e. ASICs, and customized CPUs/GPUs. The construction of this hardware will occupy many engineers for the foreseeable future. In fact, with the growing fraction of the world’s energy consumption being dedicated to computation, this will be a key part of maintaining the environment.

With that said, as with any engineering field, you should target aspects of hardware that are higher up on the value chain, work on things you enjoy, and work at companies that are leading innovation in that area.