Kontrol tablosu - Control table
Kontrol masaları olan tablolar kontrol kontrol akışını veya program kontrolünde önemli bir rol oynar. Bir kontrol tablosunun yapısı veya içeriği hakkında katı kurallar yoktur - bunun niteleyici özelliği, bir işlemci veya yorumlayıcı tarafından "yürütme" yoluyla kontrol akışını bir şekilde yönlendirme yeteneğidir . Bu tür tabloların tasarımına bazen tablo odaklı tasarım denir (ancak bu genellikle doğrudan çalışma zamanı tablolarından ziyade harici tablolardan otomatik olarak kod üretilmesine atıfta bulunur). Bazı durumlarda, kontrol tabloları, sonlu-durum-makine- tabanlı otomat-tabanlı programlamanın özel uygulamaları olabilir . Birkaç hiyerarşik kontrol tablosu seviyesi varsa, bunlar UML durum makinelerine eşdeğer bir şekilde davranabilirler.
Kontrol tabloları , genellikle, ilişkilendirme listesindeki göreli sütun konumlarıyla ima edilen, içlerinde gömülü koşullu ifadelerin veya işlev referanslarının eşdeğerine sahiptir . Kontrol tabloları, benzer yapıları veya program ifadelerini tekrar tekrar programlama ihtiyacını azaltır . Çoğu tablonun iki boyutlu yapısı, program kodunun tek boyutlu yapısından daha kolay görüntülenmelerini ve güncellenmelerini sağlar. Bazı durumlarda, kontrol tablolarını korumak için programcı olmayanlar atanabilir.
Tipik kullanım
- Giriş değerlerinin dönüştürülmesi:
- daha sonra dallanma veya işaretçi araması için bir dizin
- kontrol akışını değiştirmek için bir program adı, ilgili alt program numarası, program etiketi veya program ofseti
- Bir denetleme ana döngü içinde olaya dayalı programlamanın bir kullanarak kontrol değişkeni için devlet geçişler
- Çevrimiçi işlem işleme uygulamaları için program döngüsünü kontrol etme
Daha gelişmiş kullanım
- Bir yorumlayıcı tarafından işlenen bir sanal makine için sanal talimatlar olarak hareket etme
- bayt koduna benzer - ancak genellikle tablo yapısının kendisi tarafından ima edilen işlemlerle
Tablo yapısı
Tablolar, sabit veya değişken uzunluklarda birden fazla boyuta sahip olabilir ve genellikle bilgisayar platformları arasında taşınabilir , algoritmanın kendisinde değil, yalnızca yorumlayıcıda bir değişiklik gerektirir - mantığı esas olarak tablo yapısı ve içeriği içinde somutlaşır. Tablonun yapısı, bir veri değerinin (veya veri değerlerinin kombinasyonunun) gerçekleştirilecek bir veya daha fazla fonksiyona eşlenebildiği bir çoklu eşleme ilişkisel dizisine benzer olabilir.
Tek boyutlu tablolar
Belki de en basit uygulamada, bir kumanda tablosu için bazen tek boyutlu bir tablo olabilir , doğrudan bir çeviri ham veri karşılık gelen bir alt yordam değer ofset , dizin veya işaretçi dizi indeksi olarak ya doğrudan ham veri değeri kullanılarak, ya da gerçekleştirerek önceden verilerle ilgili bazı temel aritmetikler. Bu, sabit zamanda ( bir ilişkisel dizi üzerinde tipik bir arama tablosu kullanılarak doğrusal bir arama veya ikili arama olmadan ) elde edilebilir. Çoğu mimaride bu, herhangi bir karşılaştırma veya döngü olmaksızın iki veya üç makine talimatıyla gerçekleştirilebilir . Teknik, " önemsiz karma işlevi " veya özellikle dal tabloları için kullanıldığında " çift gönderme " olarak bilinir . Bunun uygulanabilir olması için, verilerin tüm olası değerlerinin aralığının küçük olması gerekir (örneğin , onaltılık '00' – 'FF' aralığına sahip bir ASCII veya EBCDIC karakter değeri . Gerçek aralığın daha küçük olması garanti edilirse) bundan daha fazlası, dizi 256 bayttan daha azına kesilebilir).
Ham ASCII değerlerini (A,D,M,S) tek boyutlu dizi kullanarak sabit zamanda yeni alt program indeksine (1,4,3,2) çevirme tablosu
(aralıktaki boşluklar bu örnekte '..' olarak gösterilir, yani 'sonraki satıra kadar olan tüm onaltılık değerler' anlamına gelir. İlk iki sütun dizinin parçası değildir)
| ASCII | altıgen | Dizi |
|---|---|---|
| boş | 00 | 00 |
| .. | .. | 00 |
| @ | 40 | 00 |
| bir | 41 | 01 |
| .. | .. | 00 |
| D | 44 | 04 |
| .. | .. | 00 |
| M | 4D | 03 |
| .. | .. | 00 |
| S | 53 | 02 |
Gelen otomatlar bazlı programlama ve pseudoconversational işlem belirgin bir programdan sayısı az ise, etkili bir ana program döngüsü tüm akışı dikte işlem, "yoğun sekans" kontrol değişkeni kullanılabilir.
İki baytlık bir ham veri değeri, yalnızca 256 farklı çıkış değerine izin verirken tüm giriş olasılıklarını işlemek için minimum 65.536 bayt tablo boyutu gerektirir . Bununla birlikte, bu doğrudan çeviri tekniği, yeterli hızlı erişim belleğiyle birlikte buluşsal yöntemler kullanımına izin veriyorsa, son derece hızlı bir doğrulama ve (göreli) bir alt rutin işaretçisine dönüştürme sağlar .
Şube tabloları
Bir dal tablosu , hemen önceki ve indekslenmiş bir dal ile dallara ayrıldığında bir program etiketine çok yollu bir dalı etkilemek için bitişik makine kodu dallanma / atlama talimatlarının tek boyutlu bir "dizisidir" . Girdi aralığının birkaç boşlukla (önceki dizi örneğinin oluşturduğu gibi) küçük ve yoğun olması koşuluyla , bazen bir anahtar deyimini yürütmek için optimize eden bir derleyici tarafından oluşturulur [2] .
Birden çok eşdeğer Ififadeyle karşılaştırıldığında, oldukça kompakt olmasına rağmen , şube işlem kodu ve koşul kodu maskesi, şube ofsetleriyle birlikte tekrarlandığından , şube talimatları hala bir miktar fazlalık taşır . Yalnızca program etiketlerine göre ofsetleri içeren kontrol tabloları, bu fazlalığın üstesinden gelmek için (en azından montaj dillerinde) oluşturulabilir ve yine de geleneksel bir dal tablosuna kıyasla yalnızca küçük yürütme süresi ek yükü gerektirir .
Çok boyutlu tablolar
Daha genel olarak, bir kontrol tablosu, bir Doğruluk tablosu veya basılı bir karar tablosunun (veya çeşitli seviyelerde bir karar tabloları ağacı ) yürütülebilir ("ikili") bir uygulaması olarak düşünülebilir . Bir veya daha fazla ilişkili 'eylem' ile birlikte (genellikle ima edilen) önermeler içerirler . Bu eylemler genellikle, bir " yorumlayıcı " programı tarafından çağrılan genel veya özel olarak oluşturulmuş alt rutinler tarafından gerçekleştirilir . Bu örnekte yorumlayıcı , kontrol tablosu girişlerini 'yürüten' ve böylece yorumlayıcının temel kodundan daha yüksek bir soyutlama düzeyi sağlayan bir sanal makine olarak etkin bir şekilde işlev görür .
Dile bağlı bir switch deyimine benzer satırlar boyunca bir kontrol tablosu oluşturulabilir, ancak girdi değerlerinin kombinasyonlarını test etme ( boole stili VE / VEYA koşulları kullanarak ) ve potansiyel olarak birden çok alt yordam çağırma (yalnızca tek bir değer kümesi yerine ) olasılığı eklenir . ve 'daldan' program etiketleri). (Switch deyimi yapısı her durumda mevcut olmayabilir veya yüksek seviyeli dillerde ( HLL ) kafa karıştıracak kadar farklı uygulamalara sahip olabilir . Kontrol tablosu kavramının, karşılaştırmalı olarak, hiçbir içsel dil bağımlılığı yoktur, ancak yine de mevcut olana göre farklı şekilde uygulanabilir. seçilen programlama dilinin veri tanımlama özellikleri.)
Tablo içeriği
Bir kontrol tablosu , programlama dili sözdiziminden ve platforma bağlı bileşenlerinden (örneğin IF/THEN DO.., FOR.., DO WHILE.., SWITCH, GOTO, CALL) arındırılmış, geleneksel bir programın ' özünü ' somutlaştırır ve ' değişkenlerine (örn. input1), değerlere (örn. 'A', 'S', 'M' ve 'D') ve alt program kimliklerine (örn. 'Ekle', 'çıkarma,..' veya #1, # 2,..). Tablonun yapısı tipik olarak ilgili (varsayılan) mantıksal işlemleri ima eder – örneğin 'eşitliği test etme', bir alt yordam gerçekleştirme ve 'sonraki işlem' veya varsayılan sırayı takip etme (bunlar program ifadelerinde açıkça belirtilmek yerine) gerektiği gibi diğer programlama paradigmalarında ).
Çok boyutlu bir kontrol tablosu, normalde, minimum olarak, değer/eylem çiftlerini içerecektir ve ek olarak, veri dönüştürme (veya diğer çalışma zamanı) olup olmadığı, giriş veya çıkış verilerinin konumu, boyutu ve formatı gibi operatörler ve tür bilgilerini içerebilir. işleme nüansları) işlemden önce veya sonra gereklidir (işlevin kendisinde zaten kapalı değilse). Tablo , "satır"daki diğer değerlere bağlı olarak yürütülecek genel veya özelleştirilmiş ilkellere veya alt rutinlere yönelik dizinler veya göreli veya mutlak işaretçiler içerebilir veya içermeyebilir .
Aşağıda gösterilen tablo, tabloda belirli bir girdi belirtilmediği için yalnızca 'girdi1' için geçerlidir.
yapının ima ettiği koşullar ve eylemler
(ima edilen) EĞER = (zımni) performans değer aksiyon değer aksiyon
(Bu yan yana değer ve eylem eşleştirmesi, Olay güdümlü programlamadaki yapılarla , yani 'olay algılama' ve 'olay işleme' ile benzerliklere sahiptir , ancak (zorunlu olarak) olayın asenkron doğası yoktur)
Bir kontrol tablosunda kodlanabilen değerlerin çeşitliliği , büyük ölçüde kullanılan bilgisayar diline bağlıdır . Derleme dili , (eylemler için), doğrudan çalıştırılabilir makine kodu seçeneği dahil olmak üzere veri türleri için en geniş kapsamı sağlar . Tipik olarak bir kontrol tablosu, bir eylem alt yordamına karşılık gelen bir gösterici ile birlikte her olası eşleşen girdi sınıfı için değerler içerir. Bazı diller, işaretçileri (doğrudan) desteklemediğini iddia eder, ancak bunun yerine , tablo girişindeki değer tarafından kontrol edilen koşullu yürütmeyi gerçekleştirmek için 'göreceli bir alt program numarasını' temsil etmek için kullanılabilen bir dizini destekleyebilir (örneğin, optimize edilmiş bir SWITCH'de kullanım için). ifadesi - sıfır boşluklarla tasarlanmıştır (yani, çok yollu bir dal )).
Her bir sütunun (hatta gömülü metin dokümantasyonunun) üzerinde konumlandırılan yorumlar, bir karar tablosunu, esaslarına göre 'yoğunlaştırıldıktan' (kodlamadan) sonra (ve yine de büyük ölçüde orijinal program spesifikasyonu ile uyumlu – özellikle de basılı ise) 'insan tarafından okunabilir' hale getirebilir. her benzersiz eylemi numaralandıran karar tablosu, kodlama başlamadan önce oluşturulur). Tablo girişleri ayrıca isteğe bağlı olarak 'uçuşta' veya sonraki optimizasyon için çalışma zamanı istatistiklerini toplamak için sayaçlar içerebilir.
Tablo konumu
Kontrol tabloları, statik depolamada, bir düz dosya veya bir veritabanı gibi yardımcı depolamada bulunabilir veya alternatif olarak, program başlatma zamanında parametrelerden (bunlar kendileri bir tabloda yer alabilir) dinamik olarak kısmen veya tamamen oluşturulabilir . Optimum verimlilik için, yorumlayıcı onu kullanmaya başladığında tablonun bellekte yerleşik olması gerekir.
Tercüman ve alt programlar
Tercüman, yüksek seviyeli bir dil de dahil olmak üzere herhangi bir uygun programlama dilinde yazılabilir . Uygun şekilde tasarlanmış bir jenerik yorumlayıcı, iyi seçilmiş bir dizi jenerik alt yordamlarla (en yaygın olarak ortaya çıkan ilkelleri işleyebilen ) birlikte, yalnızca yeni özel alt yordamlar için (kontrol tablosunun kendisini belirtmeye ek olarak) ek geleneksel kodlama gerektirir. Yorumlayıcı, isteğe bağlı olarak, tam bir uygulama programının yalnızca bazı iyi tanımlanmış bölümlerine ( ana kontrol döngüsü gibi ) uygulanabilir ve diğer 'daha az koşullu' bölümlere (program başlatma, sonlandırma vb.) uygulanamaz.
Yorumlayıcının aşırı derecede karmaşık olması veya bir derleyici yazarının ileri bilgisine sahip bir programcı tarafından üretilmesi gerekmez ve genellikle verimlilik düşünülerek tasarlanmış olması dışında, herhangi bir başka uygulama programı gibi yazılabilir. Birincil işlevi, tablo girişlerini bir dizi "talimat" olarak "yürütmektir". Kontrol tablosu girişlerinin ayrıştırılmasına gerek yoktur ve bu nedenle, bunlar mümkün olduğunca 'yürütmeye hazır' olacak şekilde tasarlanmalı ve değişkenlerin yalnızca uygun sütunlardan önceden derlenmiş jenerik koduna "eklenmesini" gerektirmelidir. Çevirmen. Program talimatları , teorik olarak, sonsuz olarak uzayabilir ve tek yorumlayıcıya anlamlı olan tablo içinde (muhtemelen keyfi) değerlerini oluşturmaktadır. Kontrol akış çevirmenin her bir tablo satır sıralı işlemi ile normal olarak ancak tablo girdileri belirli eylemleri ile modifiye edilebilir.
Bu keyfi değerler, böylece , veri veya fonksiyon işaretçilerine doğrudan indeksler olarak kullanılabilecek değerler seçilerek verimlilik göz önünde bulundurularak tasarlanabilir . Belirli platformlar/ diller için , dal tablosu değerlerini kullanarak talimat yolu uzunluklarını en aza indirecek şekilde özel olarak tasarlanabilirler ve hatta JIT derleyicilerinde olduğu gibi bazı durumlarda doğrudan çalıştırılabilir makine kodu " parçacıkları "ndan (veya bunlara yönelik işaretçilerden) oluşurlar .
Alt programlar, yorumlayıcının kendisi ile aynı dilde veya desteklenen herhangi bir başka program dilinde (uygun diller arası 'Çağrı' bağlantı mekanizmalarının mevcut olması şartıyla) kodlanabilir. Tercüman ve/veya alt programlar için dil seçimi, genellikle çeşitli platformlarda ne kadar taşınabilir olması gerektiğine bağlı olacaktır . Bir kontrol tablosunun taşınabilirliğini geliştirmek için yorumlayıcının birkaç versiyonu olabilir . Bir bağımlı kontrol tablosu işaretçisi, yorumlayıcı bu yapıyı destekliyorsa, geleneksel yapılandırılmış bir program yapısını taklit ederek daha düşük bir mantıksal düzeye koşullu bir "düşüş"ü temsil ediyorsa, isteğe bağlı olarak 'eylem' sütunlarındaki bir alt rutin işaretçisinin yerini alabilir .
Performans konuları
İlk bakışta, kontrol tablolarının kullanımı, bir programın ek yüküne epey bir şey katmış gibi görünebilir ve bu, 'yerel' programlama dili ifadeleri yürütülmeden önce bir yorumlayıcı süreci gerektirir. Ancak bu her zaman böyle değildir. Tabloda ifade edildiği gibi yürütülebilir kodlamayı mantıktan ayırarak (veya 'kapsülleyerek'), işlevini en verimli şekilde gerçekleştirmesi daha kolay hedeflenebilir. Bu, en açık şekilde bir elektronik tablo uygulamasında deneyimlenebilir - burada temel alınan elektronik tablo yazılımı, sonuçlarını görüntülemek için karmaşık mantıksal 'formülleri' şeffaf bir şekilde mümkün olan en verimli şekilde dönüştürür.
Aşağıdaki örnekler kısmen, yalnızca ek soyutlama katmanını önemli ölçüde telafi etmekle kalmayıp, aynı zamanda daha az verimli, daha az sürdürülebilir ve daha uzun kod üzerinde - aksi takdirde ne olabilirdi - iyileştiren potansiyel performans kazanımlarını göstermek için seçilmiştir . Verilen örnekler 'düşük seviyeli' bir montaj dili ve C dili için olmasına rağmen, her iki durumda da, kontrol tablosu yaklaşımını uygulamak için çok az kod satırının gerekli olduğu ve yine de çok önemli sabit zaman elde edebildiği görülebilir. ayrıntılı geleneksel program dili yapılarına kıyasla performans iyileştirmeleri, tekrarlayan kaynak kodlamasını azaltır ve netliğe yardımcı olur . Bu makaledeki tablolar ve çok yollu dallanmanın verimliliği ile ilgili olarak Donald Knuth tarafından yapılan alıntılara da bakın.
Kontrol tablolarına örnekler
Aşağıdaki örnekler isteğe bağlıdır (ve basitlik için yalnızca tek bir girdiye dayanır), ancak amaç yalnızca kontrol akışının düzenli program ifadeleri yerine tabloların kullanılması yoluyla nasıl gerçekleştirilebileceğini göstermektir. Bu tekniğin, sütun sayısını artırarak veya birden çok tablo girişi kullanarak (isteğe bağlı ve/veya operatörle) birden çok girdiyle başa çıkmak için kolayca genişletilebileceği açık olmalıdır. Benzer şekilde, (hiyerarşik) 'bağlı' kontrol tabloları kullanılarak, yapılandırılmış programlama gerçekleştirilebilir (isteğe bağlı olarak, alt kontrol tablolarının vurgulanmasına yardımcı olmak için girinti kullanılarak).
"CT1", basit bir arama tablosu olan bir kontrol tablosu örneğidir . İlk sütun, test edilecek girdi değerini temsil eder (göre bir zımni 'EĞER x = Giriş1') ise doğru, gelen 2. sütun (aksiyon '), bir tarafından gerçekleştirmek için bir alt yordam adresini ihtiva eder ve, çağrı (ya da atlama göre - SWITCH deyimine benzer ). Gerçekte, dönüşlü çok yollu bir daldır (bir " dinamik gönderme " biçimi ). Son giriş, eşleşmenin bulunmadığı varsayılan durumdur.
CT1
giriş 1 Işaretçi bir -->Ekle S -->Çıkar M -->Çarp D -->Böl ? -->Varsayılan
Diğer veri değerlerinin yanı sıra veri yapıları içindeki işaretçileri destekleyen programlama dilleri için , yukarıdaki tablo (CT1) , tablodan eşleşen değere göre kontrol akışını uygun bir alt rutinlere yönlendirmek için kullanılabilir (aksi halde belirtmek için bir sütun olmadan, eşitlik varsayılır) bu basit durum).
IBM/360 (maksimum 16Mb adres aralığı) veya Z/Architecture için Assembly dili örneği
Bu ilk örnek için kodlamada aramayı optimize etmek için hiçbir girişimde bulunulmaz ve bunun yerine basit bir doğrusal arama tekniği kullanılır - yalnızca kavramı göstermek ve daha az kaynak satırı göstermek için. 256 farklı giriş değerinin tümünü işlemek için, yaklaşık 265 satırlık kaynak kodu gerekliyken (esas olarak tek satırlık tablo girişleri), çoklu 'karşılaştırma ve dallandırma' normalde yaklaşık 512 kaynak satırı gerektirir ( ikili dosyanın boyutu da yaklaşık olarak yarıya iner, bir dizi 'anında karşılaştırma'/dal talimatı için yaklaşık 8 bayt yerine sadece 4 bayt gerektiren her tablo girişi (daha büyük girdi değişkenleri için tasarruf daha da büyüktür).
* ------------------ interpreter --------------------------------------------*
LM R14,R0,=A(4,CT1,N) Set R14=4, R15 --> table, and R0 =no. of entries in table (N)
TRY CLC INPUT1,0(R15) ********* Found value in table entry ?
BE ACTION * loop * YES, Load register pointer to sub-routine from table
AR R15,R14 * * NO, Point to next entry in CT1 by adding R14 (=4)
BCT R0,TRY ********* Back until count exhausted, then drop through
. default action ... none of the values in table match, do something else
LA R15,4(R15) point to default entry (beyond table end)
ACTION L R15,0(R15) get pointer into R15,from where R15 points
BALR R14,R15 Perform the sub-routine ("CALL" and return)
B END go terminate this program
* ------------------ control table -----------------------------------------*
* | this column of allowable EBCDIC or ASCII values is tested '=' against variable 'input1'
* | | this column is the 3-byte address of the appropriate subroutine
* v v
CT1 DC C'A',AL3(ADD) START of Control Table (4 byte entry length)
DC C'S',AL3(SUBTRACT)
DC C'M',AL3(MULTIPLY)
DC C'D',AL3(DIVIDE)
N EQU (*-CT1)/4 number of valid entries in table (total length / entry length)
DC C'?',AL3(DEFAULT) default entry – used on drop through to catch all
INPUT1 DS C input variable is in this variable
* ------------------ sub-routines ------------------------------------------*
ADD CSECT sub-routine #1 (shown as separate CSECT here but might
. alternatively be in-line code)
. instruction(s) to add
BR R14 return
SUBTRACT CSECT sub-routine #2
. instruction(s) to subtract
BR R14 return
. etc..
yukarıdaki örnekte tercümanın performansının iyileştirilmesi
- Yukarıdaki örnekte bir seçim yapmak için, ortalama talimat yolu uzunluğu (alt program kodu hariç) '4n/2 +3'tür, ancak n = 1 ila 64 olduğunda, yol uzunluğu ile sabit bir zamana kolayca indirgenebilir. Ham EBCDIC verilerinden CT1'e doğrudan bir dizin oluşturmak için önce 256 baytlık bir çeviri tablosu kullanılıyorsa, sıfır karşılaştırmalı '5' . n = 6 olduğunda, bu sadece 3 sıralı karşılaştırma ve dallandırma talimatına eşdeğer olacaktır. Ancak, n<=64 olduğunda, ortalama olarak çoklu karşılaştırma kullanmaktan yaklaşık 13 kat daha az talimata ihtiyaç duyacaktır . n=1 ila 256 olduğunda, ortalama olarak yaklaşık 42 kat daha az talimat kullanacaktır – çünkü bu durumda ek bir talimat gerekecektir (endeksi 4 ile çarpmak için).
İyileştirilmiş yorumlayıcı ( ortalama olarak yukarıdaki örneğe göre 26 kata kadar daha az yürütülmüş komut , burada n= 1 ila 64 ve çoklu karşılaştırmalar kullanılarak gerekenden 13 kata kadar daha az).
64 farklı giriş değerini işlemek için, yaklaşık 85 satır (veya daha az) kaynak kodu (çoğunlukla tek satırlı tablo girişleri) gerekirken, çoklu 'karşılaştırma ve dallanma' yaklaşık 128 satır gerektirir ( ikilinin boyutu da neredeyse yarı yarıya azalır - buna rağmen) 2. dizini çıkarmak için gereken ek 256 baytlık tablo).
* ------------------ interpreter --------------------------------------------*
SR R14,R14 ********* Set R14=0
CALC IC R14,INPUT1 * calc * put EBCDIC byte into lo order bits (24–31) of R14
IC R14,CT1X(R14) * * use EBCDIC value as index on table 'CT1X' to get new index
FOUND L R15,CT1(R14) ********* get pointer to subroutine using index (0,4, 8 etc.)
BALR R14,R15 Perform the sub-routine ("CALL" and return or Default)
B END go terminate this program
* --------------- additional translate table (EBCDIC --> pointer table INDEX) 256 bytes----*
CT1X DC 12AL1(00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00) 12 identical sets of 16 bytes of x'00
* representing X'00 – x'BF'
DC AL1(00,04,00,00,16,00,00,00,00,00,00,00,00,00,00,00) ..x'C0' – X'CF'
DC AL1(00,00,00,00,12,00,00,00,00,00,00,00,00,00,00,00) ..x'D0' – X'DF'
DC AL1(00,00,08,00,00,00,00,00,00,00,00,00,00,00,00,00) ..x'E0' – X'EF'
DC AL1(00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00) ..x'F0' – X'FF'
* the assembler can be used to automatically calculate the index values and make the values more user friendly
* (for e.g. '04' could be replaced with the symbolic expression 'PADD-CT1' in table CT1X above)
* modified CT1 (added a default action when index = 00, single dimension, full 31 bit address)
CT1 DC A(DEFAULT) index =00 START of Control Table (4 byte address constants)
PADD DC A(ADD) =04
PSUB DC A(SUBTRACT) =08
PMUL DC A(MULTIPLY) =12
PDIV DC A(DIVIDE) =16
* the rest of the code remains the same as first example
Daha da iyileştirilmiş yorumlayıcı ( ortalama olarak ilk örnekten ortalama 21 kat daha az yürütülen talimat (burada n> = 64) ve çoklu karşılaştırma kullanıldığında gerekenden 42 kat daha az).
256 farklı girdi değerini işlemek için, yaklaşık 280 satır veya daha az kaynak kodu gerekir (esas olarak tek satırlık tablo girişleri), oysa çoklu 'karşılaştırma ve dallandırma' yaklaşık 512 satır gerektirir ( ikili dosyanın boyutu da bir kez neredeyse yarıya iner). Daha).
* ------------------ interpreter --------------------------------------------*
SR R14,R14 ********* Set R14=0
CALC IC R14,INPUT1 * calc * put EBCDIC byte into lo order bits (24–31) of R14
IC R14,CT1X(R14) * * use EBCDIC value as index on table 'CT1X' to get new index
SLL R14,2 * * multiply index by 4 (additional instruction)
FOUND L R15,CT1(R14) ********* get pointer to subroutine using index (0,4, 8 etc.)
BALR R14,R15 Perform the sub-routine ("CALL" and return or Default)
B END go terminate this program
* --------------- additional translate table (EBCDIC --> pointer table INDEX) 256 bytes----*
CT1X DC 12AL1(00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00) 12 identical sets of 16 bytes of x'00'
* representing X'00 – x'BF'
DC AL1(00,01,00,00,04,00,00,00,00,00,00,00,00,00,00,00) ..x'C0' – X'CF'
DC AL1(00,00,00,00,03,00,00,00,00,00,00,00,00,00,00,00) ..x'D0' – X'DF'
DC AL1(00,00,02,00,00,00,00,00,00,00,00,00,00,00,00,00) ..x'E0' – X'EF'
DC AL1(00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00) ..x'F0' – X'FF'
* the assembler can be used to automatically calculate the index values and make the values more user friendly
* (for e.g. '01' could be replaced with the symbolic expression 'PADD-CT1/4' in table CT1X above)
* modified CT1 (index now based on 0,1,2,3,4 not 0,4,8,12,16 to allow all 256 variations)
CT1 DC A(DEFAULT) index =00 START of Control Table (4 byte address constants)
PADD DC A(ADD) =01
PSUB DC A(SUBTRACT) =02
PMUL DC A(MULTIPLY) =03
PDIV DC A(DIVIDE) =04
* the rest of the code remains the same as the 2nd example
C dili Örnek Bu örnek C İki tablo, birinci (CT1) basit bir kullanır arama lineer tek boyutlu bir arama tablosu - giriş (x) eşleştirerek endeksi elde etmek ve ikinci, bununla bağlantılı olan tablo (CT1p), bir atlanacak etiketlerin adresleri tablosu.
static const char CT1[] = { "A", "S", "M", "D" }; /* permitted input values */
static const void *CT1p[] = { &&Add, &&Subtract, &&Multiply, &&Divide, &&Default}; /* labels to goto & default*/
for (int i = 0; i < sizeof(CT1); i++) /* loop thru ASCII values */
{if (x==CT1[i]) goto *CT1p[i]; } /* found --> appropriate label */
goto *CT1p[i+1]; /* not found --> default label */
Bu, ham ASCII değerini (x) doğrudan CT1p'den şube adresinin yerinin belirlenmesinde kullanılmak üzere yoğun bir sıralı indeks değerine çevirmek için 256 baytlık bir tablo kullanılırsa daha verimli hale getirilebilir (yani bayt genişliğinde " dizin eşleme ") dizi). Daha sonra , tüm olası x değerleri için sabit zamanda yürütülür (CT1p, etiketler yerine işlevlerin adlarını içeriyorsa, atlama, anahtara benzer goto'yu ortadan kaldırarak, ancak performansı ek maliyetle düşürerek, dinamik bir işlev çağrısı ile değiştirilebilir. fonksiyon temizlik ).
static const void *CT1p[] = {&&Default, &&Add, &&Subtract, &&Multiply, &&Divide};
/* the 256 byte table, below, holds values (1,2,3,4), in corresponding ASCII positions (A,S,M,D), all others set to 0x00 */
static const char CT1x[]={
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x01', '\x00', '\x00', '\x04', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x03', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x02', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x03', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00'};
/* the following code will execute in constant time, irrespective of the value of the input character (x) */
i = CT1x(x); /* extract the correct subroutine index from table CT1x using its ASCII value as an index initially */
goto *CT1p[i]; /* goto (Switch to) the label corresponding to the index (0=default, 1=Add, 2=Subtract,.) - see CT1p */
Aşağıdaki Sonraki örnek, benzer bir etki yok dilde elde edilebilir verilmektedir olmayan veri yapıları işaretçi tanımları desteklemek ama bunu bir (bulunan - destek altprograma dallanma endeksli 0 tabanlı altprogram işaretçiler) dizisi. Tablo (CT2), dizini (2. sütundan) işaretçi dizisine (CT2P) çıkarmak için kullanılır. İşaretçi dizileri halinde değil desteklenen, bir anahtar deyim ya da eşdeğeri bir program, bir etiket dizisinden birine kontrol akışını değiştirmek için kullanılabilir: doğrudan, giriş işlemek (örn case0, Durum 1, Durum 2, case3, case4) ya da aksi takdirde uygun alt programa (varsayılan, Toplama, Çıkarma, Çarpma veya Bölme, ..) başa çıkmak için bir çağrı yapın (dönüşlü).
CT2
giriş 1 alt # bir 1 S 2 M 3 D 4 ? 0
Yukarıdaki örneklerde olduğu gibi, potansiyel ASCII giriş değerlerini (A,S,M,D veya bilinmeyen) gerçekten bir tablo araması kullanmadan bir işaretçi dizi dizinine çok verimli bir şekilde çevirmek mümkündür , ancak burada tutarlılık için bir tablo olarak gösterilmiştir. ilk örnek.
- CT2P işaretçi dizisi
Çok boyutlu kontrol tabloları, bazı eşleştirme kriterlerine bağlı olarak, birden fazla girdide birden fazla koşulu test edebilecek veya birden fazla "eylem" gerçekleştirebilecek yukarıdaki örneklerden "daha karmaşık" olabilen (yani özelleştirilebilir) oluşturulabilir. Bir 'eylem', başka bir bağımlı kontrol tablosuna bir işaretçi içerebilir. Aşağıdaki basit örnek, fazladan bir sütun olarak dahil edilmiş örtük bir 'VEYA' koşuluna sahiptir (küçük harf girişini işlemek için, ancak bu örnekte, bu, yalnızca, aşağıdakileri belirten küçük harfli karakterlerin her biri için fazladan bir giriş yapılarak eşit olarak ele alınabilirdi: büyük harf karakterleriyle aynı alt program tanımlayıcısı). Her girdi için gerçek çalışma zamanı olaylarını gerçekleştikçe saymak için fazladan bir sütun da dahildir.
CT3
giriş 1 alternatif alt # Miktar bir bir 1 0 S s 2 0 M m 3 0 D d 4 0 ? ? 0 0
Kontrol tablosu girdileri daha sonra prosedürel dillerdeki koşullu ifadelere çok daha benzerdir, ancak en önemlisi, gerçek (dile bağlı) koşullu ifadeler (yani talimatlar) olmadan (genel kod fiziksel olarak tablo girişlerini işleyen yorumlayıcıdadır, değil). tablonun kendisinde - yapısı ve değerleri aracılığıyla program mantığını basitçe somutlaştırır).
Bir dizi benzer tablo girişinin tüm mantığı tanımladığı bu gibi tablolarda, bir tablo giriş numarası veya işaretçisi, daha geleneksel programlarda bir program sayacının yerini etkili bir şekilde alabilir ve bir 'eylem'de sıfırlanabilir, yine aynı tablo girişi. Aşağıdaki örnek (CT4), önceki tablonun bir 'sonraki' girişi (ve/veya bir 'alter flow' ( atlama ) alt yordamı dahil) içerecek şekilde genişletilmesinin bir döngü oluşturabileceğini göstermektedir (Bu örnek aslında en etkili yol değildir. böyle bir kontrol tablosu oluşturun, ancak yukarıdaki ilk örneklerden kademeli bir 'evrim' göstererek davranışı değiştirmek için ek sütunların nasıl kullanılabileceğini gösterir.) Beşinci sütun, tek bir tablo girişi ile birden fazla eylemin başlatılabileceğini gösterir – bu durumda , her girişin normal işlenmesinden sonra gerçekleştirilecek bir eylem ('-' değerleri, 'koşul yok' veya 'eylem yok' anlamına gelir).
Yapılandırılmış programlama veya "Goto-az" kodu (' DO WHILE ' veya ' for döngü ' yapılarının eşdeğerini içeren ), uygun şekilde tasarlanmış ve 'girintili' kontrol tablosu yapılarıyla da yerleştirilebilir.
CT4 (giriş1 ve işlemi okumak için eksiksiz bir 'program', 'E' ile karşılaşana kadar tekrar eder)
giriş 1 alternatif alt # Miktar atlama - - 5 0 - E e 7 0 - bir bir 1 0 - S s 2 0 - M m 3 0 - D d 4 0 - ? ? 0 0 - - - 6 0 1
- CT4P işaretçi dizisi
Tabloya dayalı derecelendirme
Telekomünikasyon derecelendirmesinin uzmanlık alanında ( belirli bir aramanın maliyetinin belirlenmesiyle ilgili), tabloya dayalı derecelendirme teknikleri, piyasa güçleri nedeniyle kuralların sıklıkla değişebileceği uygulamalarda kontrol tablolarının kullanımını gösterir. Ücretleri belirleyen tablolar çoğu durumda programcı olmayanlar tarafından kısa sürede değiştirilebilir.
Algoritmalar yorumlayıcıda önceden oluşturulmamışsa (ve bu nedenle tabloda tutulan bir ifadenin ek çalışma zamanı yorumunu gerektiriyorsa), tabloya dayalı derecelendirme yerine "Kural Tabanlı Derecelendirme" olarak bilinir (ve dolayısıyla önemli ölçüde daha fazla ek yük tüketir) ).
E-tablolar
Bir elektronik tablo veri sayfası, boş olmayan hücrelerin alttaki elektronik tablo programına (tercüman) verileri temsil ettiği iki boyutlu bir kontrol tablosu olarak düşünülebilir. Formül içeren hücrelere genellikle eşittir işareti eklenir ve yorumlayıcı içindeki kontrol akışını değiştirerek diğer başvurulan hücrelerin işlenmesini belirleyen özel bir veri girişi türünü belirtir. Hem elektronik tabloları hem de yukarıda belirtilen "kural tabanlı derecelendirme" örneğini, programcı olmayanlar tarafından kontrol tablolarının kullanımının kolayca tanımlanabilir örnekleri olarak açıkça tanımlayan temel yorumlayıcıdan formüllerin dışsallaştırılmasıdır.
Programlama paradigması
Kontrol tabloları tekniğinin herhangi bir belirli programlama paradigmasına ait olduğu söylenebilirse , en yakın benzetme Otomata tabanlı programlama veya "yansıtıcı" olabilir (bir tür meta programlama - çünkü tablo girişlerinin davranışını 'değiştirdiği' söylenebilir. çevirmen). Ancak yorumlayıcının kendisi ve alt programlar, mevcut paradigmalardan herhangi biri veya hatta bir karışım kullanılarak programlanabilir. Tablonun kendisi esasen derlenmesi gerekmeyen ve harici bir kaynaktan okunabilen " ham veri " değerlerinin bir koleksiyonu olabilir (spesifik, platforma bağlı, daha yüksek verimlilik için doğrudan bellek işaretçileri kullanan uygulamalar hariç).
Bayt koduna benzetme / sanal makine komut seti
Çok boyutlu bir kontrol tablosu, sanal bir makinede çalışan bayt koduna bazı kavramsal benzerliklere sahiptir , burada genellikle gerçek yürütmeyi gerçekleştirmek için platforma bağlı bir "yorumlayıcı" program gerekir (bu, büyük ölçüde koşullu olarak tablo içeriği tarafından belirlenir). Ayrıca, platformdan bağımsız ortak bir ara 'talimat seti' oluşturmak amacıyla son Ortak Ara Dil (CIL) ile bazı kavramsal benzerlikler vardır (ancak CIL'den farklı olarak, diğer diller için ortak bir kaynak olarak kullanılma iddiası yoktur) . P-kodu , kökenleri 1966'ya kadar uzanan benzer ancak daha eski bir uygulama olarak da düşünülebilir.
talimat getirme
Program akışını belirlemek için çok boyutlu bir kontrol tablosu kullanıldığında, normal "donanım" Program Sayacı işlevi, ya ilk (veya sonraki) tablo girişine bir işaretçi ya da buna bir indeks ile etkin bir şekilde simüle edilir . Talimatın "getirilmesi", o tablo girişindeki verilerin kodunun çözülmesini içerir - önce giriş içindeki verilerin tümünü veya bir kısmını kopyalamak zorunda kalmadan. Kullanabilirler dilleri Programlama işaretçileri az ikili avantajı var havai içeriğini erişme ve ayrıca yürütme sonraki tablo girişine noktasına sayacı ilerleyen hem de ilgilenmektedir. Bir sonraki 'talimat' adresinin hesaplanması (yani tablo girişi) , herhangi bir aşamada döngülere ve / veya atlama talimatlarına izin veren her bir tablo girişinin isteğe bağlı bir ek eylemi olarak bile gerçekleştirilebilir .
Kontrol tablosu yürütmesini izleme
Yorumlayıcı program, hata ayıklama amaçları, etkin nokta tespiti, kod kapsamı analizi ve performans analizi için gerçek program akışının tam veya kısmi izini kaydetmek için isteğe bağlı olarak program sayacını (ve talimat türüne bağlı olarak diğer ilgili ayrıntıları) her aşamada kaydedebilir (bkz. yukarıdaki örnekler CT3 ve CT4).
Avantajlar
- netlik – Bilgi tabloları her yerde bulunur ve çoğunlukla genel halk tarafından bile doğal olarak anlaşılır (özellikle ürün kılavuzlarındaki arıza teşhis tabloları )
- taşınabilirlik – dilden %100 bağımsız olacak şekilde tasarlanabilir (ve platformdan bağımsız – tercüman hariç)
- esneklik - ilkelleri veya alt programları şeffaf bir şekilde yürütme ve soruna uyacak şekilde özel olarak tasarlanma yeteneği
- kompaktlık – tablo genellikle koşul/eylem eşleştirmesini yan yana gösterir (olağan platform/dil uygulama bağımlılıkları olmadan), genellikle aynı zamanda
- ikili dosya - talimatların daha az kopyalanmasıyla boyutu küçültülür
- kaynak dosya – birden çok koşullu ifadenin ortadan kaldırılmasıyla boyut küçültülür
- geliştirilmiş program yükleme (veya indirme) hızları
- sürdürülebilirlik – tablolar genellikle korunması gereken kaynak satırlarının sayısını azaltır v. çoklu karşılaştırmalar
- referans yeri - kompakt tablo yapıları, önbellekte kalan tablolarla sonuçlanır
- kodun yeniden kullanımı – "tercüman" genellikle yeniden kullanılabilir. Sıklıkla aynı teknik kullanılarak yeni programlama görevlerine kolayca uyarlanabilir ve 'organik olarak' büyüyerek, aslında, tablo tanımları tarafından kontrol edilen, denenmiş ve test edilmiş alt programlardan oluşan standart bir kitaplık haline gelebilir .
- verimlilik – sistem çapında optimizasyon mümkündür. Yorumlayıcıda yapılacak herhangi bir performans iyileştirmesi genellikle onu kullanan tüm uygulamaları iyileştirir (yukarıdaki 'CT1'deki örneklere bakın).
- genişletilebilir – yeni 'talimatlar' eklenebilir – sadece yorumlayıcıyı genişleterek
- tercüman bir uygulama programı gibi yazılabilir
İsteğe bağlı olarak: -
- yorumlayıcı içe dönük olabilir ve tablonun kendisinde toplanan çalışma zamanı ölçümlerini kullanarak "kendini optimize edebilir " (bkz. CT3 ve CT4 – azalan sayıya göre periyodik olarak sıralanabilen girişler). Yorumlayıcı ayrıca isteğe bağlı olarak çalışma zamanında toplanan metriklerden dinamik olarak en verimli arama tekniğini seçebilir (örn. dizinin boyutu, değer aralığı, sıralanmış veya sıralanmamış)
- dinamik gönderme – bellek kullanımını azaltmak için ortak işlevler önceden yüklenebilir ve daha az yaygın işlevler yalnızca ilk karşılaşmada getirilebilir . Bunu başarmak için tablo içi notlandırma kullanılabilir.
- Yorumlayıcı, yerleşik hata ayıklama, izleme ve izleme özelliklerine sahip olabilir – bu özellikler daha sonra test veya 'canlı' moda göre istendiğinde açılıp kapatılabilir
- kontrol tabloları 'anında' oluşturulabilir (bazı kullanıcı girdilerine göre veya parametrelere göre) ve daha sonra yorumlayıcı tarafından çalıştırılabilir (kelimenin tam anlamıyla kod oluşturmadan).
Dezavantajları
- eğitim gereksinimi - uygulama programcıları genellikle genel çözümler üretmek için eğitilmez
Aşağıdakiler, daha önce tartışılan tek boyutlu tablolarda değil, esas olarak çok boyutlu tablolarda kullanımları için geçerlidir.
- ek yük – 'yorumlanması' gereken sanal talimatların neden olduğu ekstra dolaylı seviye nedeniyle bir miktar artış (ancak bu genellikle, verimli doğrudan çeviri, arama ve koşullu test tekniklerinden tam olarak yararlanan iyi tasarlanmış bir genel yorumlayıcı tarafından dengelenmekten daha fazlası olabilir. başka türlü kullanılmamıştır)
- Karmaşık ifadeler , karşılaştırma amacıyla veri tablosu girişlerinde her zaman doğrudan kullanılamaz
- (ancak bu 'ara değerler', bir alt yordam içinde önceden hesaplanabilir ve bunların değerleri koşullu tablo girişlerinde belirtilebilir. Alternatif olarak, bir alt yordam tam karmaşık koşullu testi gerçekleştirebilir (koşulsuz bir 'eylem' olarak) ve bir sonucu olarak doğruluk bayrağı , daha sonra bir sonraki tablo girişinde test edilebilir.Yapılandırılmış program teoremi'ne bakın )
alıntılar
Çok yollu dallanma, çoğu zaman verimsiz bir if testleri dizisiyle değiştirilen önemli bir programlama tekniğidir. Peter Naur geçenlerde bana, program akışını kontrol etmek için tabloların kullanımını bilgisayar biliminin neredeyse unutulmuş temel bir fikri olarak gördüğünü yazmıştı; ama her an yeniden keşfedilmek için olgunlaşacağını umuyor. Çalıştığım en iyi derleyicilerde verimliliğin anahtarıdır.
— Donald Knuth , Yapılandırılmış Programlama ile Açıklamalara git
Yorumlayıcı dilde yazılmış bir programa bakmanın başka bir yolu daha var. Birbiri ardına bir dizi altyordam çağrısı olarak kabul edilebilir. Böyle bir program aslında alt rutinler üzerinde uzun bir çağrı dizisine genişletilebilir ve bunun tersine, böyle bir dizi genellikle kolayca yorumlanabilen kodlanmış bir forma paketlenebilir. Yorumlayıcı tekniklerin avantajı, temsilin kompaktlığı, makine bağımsızlığı ve artan tanılama yeteneğidir. Bir yorumlayıcı genellikle, kodun kendisinin yorumlanması ve uygun rutine dallanması için harcanan zamanın ihmal edilebilecek kadar az olduğu şekilde yazılabilir.
- Donald Knuth , The Art of Computer Programming Volume 1, 1997, sayfa 202
Bir programı temsil etmek için gereken alan, genellikle, ortak işlem dizilerinin kompakt bir şekilde temsil edildiği yorumlayıcıların kullanımıyla azaltılabilir. Tipik bir örnek, karmaşık bir protokolü veya sözcük biçimini küçük bir tabloya kodlamak için sonlu durumlu bir makinenin kullanılmasıdır.
— Jon Bentley , Verimli Programlar Yazma
Sıçrama tabloları, özellikle menzil testleri atlanabiliyorsa verimli olabilir. Örneğin, kontrol değeri numaralandırılmış bir tür (veya bir karakter) ise, o zaman yalnızca küçük bir sabit değer aralığı içerebilir ve atlama tablosunun tüm olası değerleri işleyecek kadar büyük olması koşuluyla bir aralık testi gereksizdir.
- David.A. SPULER, Statik Arama Problemi Olarak Çok Yönlü Dal İfadeleri için Derleyici Kodu Oluşturma
Programlar insanların okuması için ve sadece tesadüfen makinelerin çalışması için yazılmalıdır.
- "Bilgisayar Programlarının Yapısı ve Yorumlanması", birinci baskıya önsöz, Abelson & Sussman
Bana akış çizelgenizi gösterin ve tablolarınızı gizleyin, ben de şaşırmaya devam edeceğim. Bana tablolarınızı gösterin, genellikle akış şemanıza ihtiyacım olmayacak; belli olacak.
- "Efsanevi Adam-Ayı: Yazılım Mühendisliği Üzerine Denemeler", Fred Brooks
Ayrıca bakınız
- Otomat tabanlı programlama
- Veritabanı merkezli mimari
- Veriye dayalı test
- Karar tablosu
- Sonlu durum makinesi
- Anahtar kelimeye dayalı test
- İşaretçi (bilgisayar programlama)
- Switch deyimi - tek bir giriş değişkenine bağlı olarak bir dizi program etiketinden birine çok yönlü dallanma
- Dişli kod
- Jeton iş parçacığı
Notlar
Referanslar
- Karar Tablosuna Dayalı Metodoloji
- Yapılandırılmış Tablolara halindeyken ile Programlama tarafından Donald Knuth
- Statik arama problemi olarak çok yollu dal ifadeleri için derleyici kodu üretimi 1I994, David A. Spuler
Dış bağlantılar
- Windows PowerShell'deki anahtar deyimi, standart anahtar deyiminin uzantılarını açıklar (kontrol tablolarına bazı benzer özellikler sağlar)
- İşaretçileri kullanan "C" dilinde Kontrol Tablosu örneği , Christopher Sawtell c1993, Bilgisayar Bilimleri Bölümü , Auckland Üniversitesi
- DataKinetics'ten Wayne Cunneyworth tarafından tablo odaklı tasarım
- Gereksinimlerden Tablolara, Kod ve Testlere George Brooke
- Belirsiz karar tablolarının kullanımı ve bunların bilgisayar programlarına dönüştürülmesi hakkında bazı yorumlar PJH King ve RG Johnson, Univ. Londra, Londra, Birleşik Krallık
- PJH King tarafından sınırlı giriş karar tablolarında belirsizlik
- Karar tablolarının PJH King tarafından kural maskesi teknikleriyle bilgisayar programlarına dönüştürülmesi
- Çok Yollu Şube Kodu Oluşturmanın Süper İyileştirici Analizi bölüm 3.9, sayfa 16 dizin eşleme
- C/C++ Jones, Nigel'da İşlev İşaretçi Dizileri aracılığıyla Tabloları Atlayın. "İşlevlere İşaretçi Dizileri [3] " Gömülü Sistem Programlama, Mayıs 1999.
- Aralık 2009 için bu makale için sayfa görüntüleme istatistikleri