NI Labs

cancel
Showing results for 
Search instead for 
Did you mean: 

Feedback on NI Labs

Hello,
 
Your existing software is ideal for a completely new compiler.  In detail, it would revolve around your basic logic gate symbols.  At present, the ALU of a processor can perform certain boolean tasks, and I am going to do my best to explain how you can write a program language that will operate faster than any of the known languages present.  The processor doesn't need to run faster to do more and that is what I am going to explain.
 
Using logic gates over if statements and other form of basic language converts data into sets that are represented by 1s or 0s.  The Algebra of Sets and all of the methods used in Boolean Algebra for the reduction of the number for any given microchip, processor or functional logic chip, does allow for a new programming language based upon the methods and means utilized in designing chips for a specific function, to write a program for a specific function.  In all of the major languages, you can write a program that does what you want thousands of different ways, but in truth there is only one that uses the least number of instructions to the CPU to achieve that task.  When your command set consists of only logic gates, boolean operations can be utilized to reduce the number of commands in any given program.  But, writing a programming language in this fashion does propose differences between circuits and commands sent to the CPU.
 
When you check to see if two variables are the same value, basically you are using a binary decoder that produces and output of 1 if two given values are equal.  Greater than and Less than are similar and for all intensive purposes are also decoders in your most basic computer language.  The way most computer languages handle is, is with a 32 or 64 bit wide pipe, and the result is still a 32 or 64 bit position in memory, later I will explain how you can structure a program to do several operations at one time once the information is and has been converted into sets represented by 1s, this is to rebuild the IF statement in computer language into a faster running method by eliminating it, and replacing it loops and gate logic.  First, you as a programmer need to know that sets include graphics, results from the ALU, and certian math functions are literal, meaning that the Fortran Machine Code Operation for that itteration or series of itterations is pretty well maximized within that language.  If the CPU included all of the primary logic gates as a function, it would then be possible to run more commands in parallel in the end because, there is a folding point once everything is represented by sets converted to 1s and 0s.
 
In one sense an AND gate could be represented by incrementing a counter and checking value.  If the value doesn't comply, clear the counter, a jump statement would send to checking input statements.  In another case, there could be 30 or 40 gates and the list of values/conditions checked to set 1s and 0s in a bitwise operation then both inputs sent to the CPU as a function for the ALU in a process of ANDing.  At that point the checklist isn't any different any computer language, but at the point where you slammed all of that into ALU to AND it, it was different and did preform all of the logical operations in one swoop.  This means that after reducing the number of gate via boolean operation, the software should be able define which gates could be checked together for 1s and 0s and input states because, that list won't move any faster, but conditions and what the CPU could do next could be done faster and much faster.  So, when you have a group of logic gates, that represents a program loop, escaping that loop is based on the condition of an output of a given gate that may lead to another loop, function, equation, port, screen command, sound etc. Assigning states could mean that you are looking for an input from a device per say a keyboard or mouse's point and which button clicked.  Draw a line too it.  What you will find is that there are allot less commands in what could or would have been nested if statements and loops in any other language.
 
In machine language this consists of counting commands, clock cycles and looking at when which gate is ideal, a 2 input AND gate, when to use the ALU to check a series of gates at the same time for states, remembing that this is not setting the input values of 1s and 0s and that there will be a check list to set the states.  The bigger and more complex the program in function, the more it will be able to do in as if the language were operating as a log function on a calculator to convert db to watts.  The size and execution time decrease over other languages, and it's just a project that includes getting the custom chip designers and engineers into the same room with the programmers to write the macros for the gates and of course counting clock cycles and CPU instructions as to when to switch, and if anything writing to the CPU manufactures to include all of the logical gates in the CPU's ALU, and or significant options, like 3 and 4 input gates that are checked as a bitwise operation other than some of the familiars to programmers in bitwise operations like AND and XOR.
0 Kudos
Message 11 of 20
(11,383 Views)

First, welcome to the forums.

Second, don't take this the wrong way, because the suggestion at least seems to be thought out, but I doubt this would be useful.

 

To elaborate, I didn't go over all the details of everything you proposed and I don't have the necessary background to understand them properly anyway, so I won't touch on any technical points.
However, here are some purely practical issues:

  1. Do you know what LabVIEW actually does behind the scenes today to be able to suggest a "faster" way? Here's a (pretty old and simpified) example. I'm sure it's more complex today and with real code. Are you sure you can replace that?
  2. Do you understand all the intricacies of data-flow (e.g. memory management, execution scheduling, race conditions, etc.)?
  3. Do you really think a new compiler will be as reliable as a compiler which has been in incremental development over 20 years? This is important. People don't want their existing code to break when they upgrade.
  4. In your last paragraph, you seem to suggest that this would require modifying the hardware. NI doesn't create the CPUs and that doesn't look like something the CPU manufacturers are likely to do.

___________________
Try to take over the world!
0 Kudos
Message 12 of 20
(11,379 Views)

Yes, I am familar with memory, caches, data flow etc.  I am attempting to replace the if statement with a different, better and faster implimentation of logic.  These symbols would be added to the graphic language.

Now, this binary adder would represent a single section of code inside of a loop, in the program language any highlighted box filled with gates is a loop.  Connect the output of that given loop to any other loop or output.

 

Carry in, A and B can be sent through the ALU for NOT at the same time.  Checking the conditions would consist of moving information through memory based upon where it stored.  Some part of that data could come from a USB port, or somewhere in the Data Cach on the CPU.  So, first you have a list of commands that provide you with the data you need for 1s and 0s on those inputs.  Then, the next thing that would happen since the values are set, the ALU has a logical AND Function, I can check AND gates 0 through 3 by providing the ALU with two sets of 1s and 0s, and AND all four gates to find the condition or logical state on all four gates.  The reason why is ANDing via the ALU is a bitwise operation.  That means that in the DATA cach is two binary Dwords for a 64 bit system and a single Dword for a 32.  The next row of AND gates down could all then be checked at the same time as well.  Eliminate nested if statements, and the result is that you can do this.  As far as writing applications is concerned it's a better way of handling graphics.  But, an image isn't handled as an image, but a set that is represented by a state of 1 or 0.  The more times I can utilize the ALU over routing information around and around through the CPU all flowing at 32 or 64 bits wide, the bitwise operation would take place in one of the registers.  When I am checking four gates at one time I use two registers to produce bitwise operations and run through a list of checks to find states of Carry in, A and B.  Where it speeds up is where the list is just 1s and 0s and the state is placed into the Register.  The final move is to send both to the ALU and find the combined result.  No real application is going to use a binary adder.  It's just that the logic of gates can be applied to machine language in a way that the if statement doesn't operate like an 8 foot pipe and just a water line to a faucet when all you need a faucet not a fire hydrant.  It makes room to do more at once than the flow of information in a language like C or Visual Basic would really allow.  They are function modules.  It also helps to eliminate long names in variables, strings, and the only time anything like that would be used in a program would be for chaining a program, or a DLL, or some other program that was designed to grant another program access like a driver.  The long names make it easy for programmers to access and control the program from the outside.  Inputs are basically locations in memory and if there were nothing on all three inputs, the result is 0, faster excution would be to jump all of the other instructions or just continue to check the inputs in the first loop.  When there is something on the input side, then it will work to the output.  Although, you would have highlighted all of those gates.  The binary adder is a bad example except for program flow because, you could just send two numbers to the ALU and get it done in one clock cycle.  But, the inputs and outputs could be from any set it is connected like a button/set of pixels, greater than or less than function reading a port.  Equal to, Less than and Greater than are all decoders and there is no reason to use this kind of logic in programming to design that kind of decoder.  But, if a number has to be greater than and less than two numbers for x on the screen, greater than and less than two numbers for y on the screen, you have four potential 1s that all need to be present and true before the mouse button is clicked which would be the fifth condition.

In a series of if statements the program flow is much different, and a program can be written to where the CPU has to read through everything without an escape or reason.  So, that binary adder really represents nested if statements.

So your source code can then be reduced once you've managed to get what you want to happen to happen, software can reduce the number of instructions to the minimum number of instructions.

http://en.wikipedia.org/wiki/Circuit_minimization

It is just that the ALU does not support all of the basic logic gate functions, XOR, NOT, AND, but there is a total of 7 that would need to be implimented.  It's only because the ALU only requires one clock cycle to preform the task up to 32 or 64 bits.  Then there is the proposition of how many inputs/registers are available to 1 clock pulse for the ALU.  The ability to ADD 10 seperate numbers at one time from ten seperate registers.  That may not be possible or simple enough fit, but the gate logic sure is for two inputs.  All it would do is speed up the process.  I am certain that it will take several macros/machine language instruction sets to impliment this in how much differently because, you would always look at eliminating the maximum number of clock pulses required for a function written.  So, for awhile you would be comparing to C to establish where the turning point is and the instructions really run faster.  In any case, when you write the program, the graphic style wouldn't change because, you can apply those rules of reduction.

 

 

0 Kudos
Message 13 of 20
(11,369 Views)
I'm not a computer scientist, but I think LabVIEW FPGA comes very near to the ideas you represent, it directly links code to gates on the FPGA chip.

Ton
Free Code Capture Tool! Version 2.1.3 with comments, web-upload, back-save and snippets!
Nederlandse LabVIEW user groep www.lvug.nl
My LabVIEW Ideas

LabVIEW, programming like it should be!
0 Kudos
Message 14 of 20
(11,363 Views)

I'm not a computer scientist either, and I still don't understand your suggestion, so I can't really comment on it.

With regards to the line "These symbols would be added to the graphic language...", LabVIEW already has those gates, but I have no idea what kind of machine code they produce, and frankly, I don't care that much. The point of high level languages is to hide the low level details, so that you don't have to care about them, and LabVIEW does a very good job of that, for which I am grateful.


___________________
Try to take over the world!
0 Kudos
Message 15 of 20
(11,361 Views)


Message Edited by Ravens Fan on 06-29-2008 10:41 PM
0 Kudos
Message 16 of 20
(11,338 Views)


Ravens Fan wrote:
Any chance this could be the return of Alfa1?
No, this is not his style at all. Anyway, alfa never left, he's still being paranoid and incoherent on LAVA (although apparently now he's back in Romania, so at least the mounties aren't after him anymore Smiley Happy ).

___________________
Try to take over the world!
0 Kudos
Message 17 of 20
(11,335 Views)
I wrote that because I cannot afford your software.  But, if you choose to write programs or applications it should work out much better if you use logic gates over C, or Visual Basic.  Once upon a time, I wrote to National Instruments, with an idea for a program language.  I do not have the money to pay for the software, and would love a copy.  I studied very hard figuring out how a computer could go faster without overclocking or major hardware changes.  Still, AMD and Intel, need to know about this language in particular if you really all of those symbols present.  If the ALU can perform all of those boolean logical functions in the same manner as it presently ANDs, NOTs and XORs, this language's macros will be shorter, faster and capable of doing more in less time using Boolean Logic and Gate Reduction Alogorithms, as well as the Algebra of Sets to determin which gates can be checked at the same time once information has been reduced to a set that is represented by a 1 or 0.  In component land, it's a function of switch and a preprogrammed output, a readout and display using BCD displays and these days the LCD displays.
 
Just because, I'm talking through the wrong hole now, doesn't mean that was always the case.
 
In the case of taking over the world, well they are helping me...
0 Kudos
Message 18 of 20
(11,331 Views)

A request for future LabVIEW versions:  Have LabVIEW be able to save vis in a form readable by older versions (more than one version old).  Also, make older versions of LabVIEW able to read newer version's vis, with some parts broken, not shutting out entirely as it does now.  This is important because we have to keep some machines at older versions of LabVIEW because they are configuration controlled.  Also, some of our co-workers at other sites go to the newest version of LabVIEW as soon as it is available, making their work unreadable by the rest of us who have to wait until the newest version becomes available to us.

 

Thanks for your consideration!

0 Kudos
Message 19 of 20
(10,128 Views)
Even i also suggest that add the modules for the PIC and 8051 controllers.
0 Kudos
Message 20 of 20
(10,029 Views)