john-dev - jumbo john.cong .include of files and sections

Follow @Openwall on Twitter for new release announcements and other news
[<prev] [next>] [thread-next>] [day] [month] [year] [list]
Message-ID: <63AA299843954871880FE2DA69D5D55C@ath64dual>
Date: Tue, 30 Aug 2011 00:25:54 -0500
From: "JFoug" <jfoug@....net>
To: <john-dev@...ts.openwall.com>
Subject: jumbo john.cong   .include  of files and sections

I have turned in an updated version (replacement version) of patch 0001 and 
0002 for jumbo-6rc1.  This patch should be installed over a clean j6-rc1. 
It repalces the prior 2 patches.   This one allows any section to be 
included inside of another section. Also, files are included.

NOTE, the problems I had with recursive includes on the sections is a thing 
of the past.  The new version, will only include a prior defined section, 
that is NOT the current section.  Thus, any section include can only be one 
level deep, and never recurse.   The 4 deep max logic for includeing of 
files has been kept.  It is an adequate safety net.

I have updated the dox some, listing the new features.

Also, within the conf file, I ripped out the jumbo16, jumbo32 and generic 
sections.  I put them into their own .conf files, and include them.

I have also added Inc:all15, Inc:all6, Inc:all7, Inc:all8 to go along with 
Inc:all.   There are now 2 extern:double.  The original, and a double10. 
The double10, starts at 10 chars, and does not grow (it assumes 
that -ext:double was already run).   I also changed -extern:parallel 
into -extern:parallel1_2 and added a new -extern:parallel2_2

Those examples should be enough for people to get a view of what can be done 
with the .include's.


One note, for externs.   In externs, you can not define variable or function 
more than once. So, to share code in the parallel, I made this section 
(minus all comments):

[List.External_base:Parallel]
int node, total;   // This node's number, and node count
int number;    // Current word number
void filter()
{
 if (number++ % total)  // Word for a different node?
  word = 0;  // Yes, skip it
}


Then these are the 2 'extern' classes:

[List.External:Parallel1_2]
.include [List.External_base:Parallel]
void init()
{
 node = 1; total = 2; // Node 1 of 2
 number = node - 1;  // Speedup the filter a bit
}
[List.External:Parallel2_2]
.include [List.External_base:Parallel]
void init()
{
 node = 2; total = 2; // Node 2 of 2
 number = node - 1;  // Speedup the filter a bit
}

I did somewhat the same 'type' coding in double.  I first made the length 
break a var (was a constant in the code). Also, I made the 'current' array 
larger (was 9 ints, now 15).  I 'could' have defined the array for both 
sections that included the base, but I thought it easier to put them into 
the 'base' section.  Also, I named that base section 
[List.External_base:Double], so that it could not be run by mistake.  The 
only thing in the extern:double and extern:double10, is the init() function 
(which is not in the base).   Pretty trivial and powerful, once I figured 
out exactly what could and could not be done with the .include stuff in 
these externs.

Any of the [List.*] sections are trivial. When you perform a .include, all 
of the lines from that section, simply get shoved into the current section. 
Any of the 'non' [List.*] sections (such as Incremental, or others), have 
all of the params from the other section loaded.  Then params that happen 
after the .include, will takeover for whatever was in the .include.

Jim.
Confused about mailing lists and their use? Read about mailing lists on Wikipedia and check out these guidelines on proper formatting of your messages.