CamCASP/Programming/6 - Revision history

import>Am592: /* query_record_handler */

2010-04-20T17:00:44Z

query_record_handler

← Older revision		Revision as of 17:00, 20 April 2010
Line 86:		Line 86:

	===query_record_handler===		===query_record_handler===
			<pre>
			subroutine query_record_handler(filename,info,filestatus,&
			& len_first_rec,num_records,printinfo)
			!performs some queries on the file filename.
			!INPUT:
			! filename = character(10)
			! printinfo = T or F (optional)
			!OUTPUT:
			! info = 0 Normal exit
			! < 0 Errors
			! (All optional)
			! filestatus = 'NEW' or 'OLD'
			! len_first_rec = length of the first record after the TOC
			! num_records = number of records written
			!On exit the file is closed.
			</pre>

import>Am592: /* leave_record_handler */

2010-04-20T17:00:09Z

leave_record_handler

← Older revision		Revision as of 17:00, 20 April 2010
Line 77:		Line 77:

	===leave_record_handler===		===leave_record_handler===
			<pre>
			subroutine leave_record_handler(filename,info,printinfo)
			implicit none
			character(10), intent(in) :: filename
			integer, intent(out) :: info
			logical, optional, intent(in) :: printinfo
			</pre>

	===query_record_handler===		===query_record_handler===

import>Am592: /* read_record */

2010-04-20T16:59:41Z

read_record

← Older revision		Revision as of 16:59, 20 April 2010
Line 67:		Line 67:

	===read_record===		===read_record===
			<pre>
			character(10), intent(in) :: filename !file to be read from
			integer, intent(in) :: indexX !position of record to be read in
			character(8), intent(in) :: labelX !label of the record
			real(dp), dimension(:), intent(out) :: X !array to be filled up
			integer, intent(out) :: info
			logical, optional, intent(in) :: printinfo
			</pre>

	===leave_record_handler===		===leave_record_handler===

import>Am592: /* write_record */

2010-04-20T16:59:07Z

write_record

← Older revision		Revision as of 16:59, 20 April 2010
Line 56:		Line 56:

	===write_record===		===write_record===
			<pre>
			! filename = character(10) name of file to write to
			! indexX = index of array X in the TOC
			! X = read(dp) array to be written
			! indicesX = integer array of indices of X
			! info = 0 Normal exit
			! < 0 Errors
			!
			</pre>

	===read_record===		===read_record===

import>Am592: /* init_record_handler */

2010-04-20T16:58:38Z

init_record_handler

@@ Line 10: / Line 10: @@
 User-accessible subroutines of record_handler.F90 and functionality:
 ===init_record_handler===
 ===write_record===

import>Am592 at 16:57, 20 April 2010

2010-04-20T16:57:13Z

← Older revision		Revision as of 16:57, 20 April 2010
Line 2:		Line 2:

	CamCASP uses objects (matrices and vectors) that can be stored as direct access files. This allows the code to free memory on demand in a dynamic manner. At present, the files I/O is handled by '''record_handler.F90'''. This module is now about 6 years old and is unnecessarily complicated and probably slow (no tests were ever done). Also, recent versions of '''gfortran''' seem to be unable to handle the module correctly with the result that we cannot access files larger than about 512MB. I'm not sure what's causing this. It could very well be a genuine bug in the module, or elsewhere, but it is proving rather hard to find. The main reason for this is the complexity of '''record_handler.F90'''. So I feel like the time has come for us to retire this module.		CamCASP uses objects (matrices and vectors) that can be stored as direct access files. This allows the code to free memory on demand in a dynamic manner. At present, the files I/O is handled by '''record_handler.F90'''. This module is now about 6 years old and is unnecessarily complicated and probably slow (no tests were ever done). Also, recent versions of '''gfortran''' seem to be unable to handle the module correctly with the result that we cannot access files larger than about 512MB. I'm not sure what's causing this. It could very well be a genuine bug in the module, or elsewhere, but it is proving rather hard to find. The main reason for this is the complexity of '''record_handler.F90'''. So I feel like the time has come for us to retire this module.

			=='''record_handler.F90'''==
			This module was constructed at a time when I needed to use integrals from the '''SAPT''' code and (rightly) wanted to hide the complex file structure from the higher-level modules. In this structure, each matrix is stored in a fixed record length direct-access file in a linked-list like manner. The first record contains the table of contents that indexes the records written. This is followed by the data. Matrix rows can be written across multiple records, furthermore, a list of indices is written along with the data, so sparse matrices can be stored. There's more to it, but this will do. It can do a lot, but at the expense of complexity and CPU power.

			Much of the functionality is no longer used. We no longer use integrals from SAPT, and we do not use sparsity. Also, there is no fundamental reason to use records of fixed length, instead we can very well use record lengths that depend on the size of the matrix. I am doing this now with records of 50000 double precision reals (400000 bytes long). This is a 19GB large file. And is likely the upper bound on files we would access - for larger systems, we'd have to go parallel. If we settle for variable record length direct-access files, we no longer need a table of contents and could dramatically simplify the structure of the file.

			User-accessible subroutines of record_handler.F90 and functionality:
			===init_record_handler===

			===write_record===

			===read_record===

			===leave_record_handler===

			===query_record_handler===

import>Am592 at 16:29, 20 April 2010

2010-04-20T16:29:33Z

New page

[[CamCASP]] => [[CamCASP/Programming | Programming]] => Direct Access Files

CamCASP uses objects (matrices and vectors) that can be stored as direct access files. This allows the code to free memory on demand in a dynamic manner. At present, the files I/O is handled by '''record_handler.F90'''. This module is now about 6 years old and is unnecessarily complicated and probably slow (no tests were ever done). Also, recent versions of '''gfortran''' seem to be unable to handle the module correctly with the result that we cannot access files larger than about 512MB. I'm not sure what's causing this. It could very well be a genuine bug in the module, or elsewhere, but it is proving rather hard to find. The main reason for this is the complexity of '''record_handler.F90'''. So I feel like the time has come for us to retire this module.